import Mathlib.Algebra.Group.Defs
import Mathlib.Init.Algebra.Order
import ECTate.Algebra.Ring.Basic
import Mathlib.Init.Data.Nat.Lemmas
import ECTate.Init.Data.Int.Lemmas
import ECTate.Data.Nat.Enat
import Mathlib.Init.Data.Int.Basic
import ECTate.Algebra.EllipticCurve.Kronecker
import Mathlib.Tactic.LibrarySearch
import Mathlib.Tactic.Ring
import Mathlib.Tactic.Convert
--class ValueMonoid (A : Type u) extends AddCommMonoid A, LinearOrder A

open Enat

section Obvious

lemma match_non_zero: ∀ {β : Sort u_1} (x : ℕ∪∞) {c1 c2 : β},
  x ≠ 0 →
    (match x with
      | ofN Nat.zero => c1
      | x => c2) =       c2
match_non_zero (x: ℕ∪∞
x : ℕ∪∞: Type
ℕ∪∞) {c1: β
c1 c2: β
c2 : β: ?m.5
β} : x: ℕ∪∞
x ≠ 0: ?m.18
0 → (match x: ℕ∪∞
x with | 0: ℕ∪∞
0 => c1: β
c1 | _ => c2: β
c2) = c2: β
c2 := by
  β: Sort u_1

x: ℕ∪∞

c1, c2: β

x ≠ 0 →
  (match x with
    | ofN Nat.zero => c1
    | x => c2) =     c2intro h: x ≠ 0
hβ: Sort u_1

x: ℕ∪∞

c1, c2: β

h: x ≠ 0

(match x with
  | ofN Nat.zero => c1
  | x => c2) =   c2
  β: Sort u_1

x: ℕ∪∞

c1, c2: β

x ≠ 0 →
  (match x with
    | ofN Nat.zero => c1
    | x => c2) =     c2match x: ℕ∪∞
x with
  β: Sort u_1

x: ℕ∪∞

c1, c2: β

h: x ≠ 0

(match x with
  | ofN Nat.zero => c1
  | x => c2) =   c2| ofN: ℕ → ℕ∪∞
ofN 0: ℕ
0 =>β: Sort u_1

x: ℕ∪∞

c1, c2: β

h: ofN 0 ≠ 0

(match ofN 0 with
  | ofN Nat.zero => c1
  | x => c2) =   c2 β: Sort u_1

x: ℕ∪∞

c1, c2: β

h: x ≠ 0

(match x with
  | ofN Nat.zero => c1
  | x => c2) =   c2exact False.elim: ∀ {C : Sort ?u.636}, False → C
False.elim (h: ofN 0 ≠ 0
h (Eq.refl: ∀ {α : Sort ?u.638} (a : α), a = a
Eq.refl 0: ?m.641
0))
Goals accomplished! 🐙
  β: Sort u_1

x: ℕ∪∞

c1, c2: β

h: x ≠ 0

(match x with
  | ofN Nat.zero => c1
  | x => c2) =   c2| ∞ =>β: Sort u_1

x: ℕ∪∞

c1, c2: β

h: ∞ ≠ 0

(match ∞ with
  | ofN Nat.zero => c1
  | x => c2) =   c2 β: Sort u_1

x: ℕ∪∞

c1, c2: β

h: x ≠ 0

(match x with
  | ofN Nat.zero => c1
  | x => c2) =   c2simp
Goals accomplished! 🐙
  β: Sort u_1

x: ℕ∪∞

c1, c2: β

h: x ≠ 0

(match x with
  | ofN Nat.zero => c1
  | x => c2) =   c2| ofN: ℕ → ℕ∪∞
ofN (β: Sort u_1

x: ℕ∪∞

c1, c2: β

n: ℕ

h: ofN (n + 1) ≠ 0

(match ofN (n + 1) with
  | ofN Nat.zero => c1
  | x => c2) =   c2n: ℕ
nWarning: unused variable `n` [linter.unusedVariables]
β: Sort u_1

x: ℕ∪∞

c1, c2: β

n: ℕ

h: ofN (n + 1) ≠ 0

(match ofN (n + 1) with
  | ofN Nat.zero => c1
  | x => c2) =   c2+1) =>β: Sort u_1

x: ℕ∪∞

c1, c2: β

n: ℕ

h: ofN (n + 1) ≠ 0

(match ofN (n + 1) with
  | ofN Nat.zero => c1
  | x => c2) =   c2 β: Sort u_1

x: ℕ∪∞

c1, c2: β

h: x ≠ 0

(match x with
  | ofN Nat.zero => c1
  | x => c2) =   c2simp
Goals accomplished! 🐙

theorem nat_mul_left_cancel: ∀ (a b c : ℕ), a ≠ 0 → a * b = a * c → b = c
nat_mul_left_cancel (a: ℕ
a b: ℕ
b c: ℕ
c : Nat: Type
Nat) (h: a ≠ 0
h : a: ℕ
a ≠ 0: ?m.940
0) : a: ℕ
a * b: ℕ
b = a: ℕ
a * c: ℕ
c → b: ℕ
b = c: ℕ
c :=
Nat.eq_of_mul_eq_mul_left: ∀ {m k n : ℕ}, 0 < n → n * m = n * k → m = k
Nat.eq_of_mul_eq_mul_left (Nat.pos_of_ne_zero: ∀ {n : ℕ}, n ≠ 0 → 0 < n
Nat.pos_of_ne_zero h: a ≠ 0
h)

end Obvious

structure SurjVal: {R : Type u} → R → [inst : IntegralDomain R] → Type u
SurjVal {R: Type u
R : Type u: Type (u + 1)
Type u} (p: R
p : R: Type u
R) [IntegralDomain: Type ?u.1068 → Type ?u.1068
IntegralDomain R: Type u
R] where
  v: {R : Type u} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v : R: Type u
R → ℕ∪∞: Type
ℕ∪∞
  v_uniformizer: ∀ {R : Type u} {p : R} [inst : IntegralDomain R] (self : SurjVal p), SurjVal.v self p = ofN 1
v_uniformizer : v: R → ℕ∪∞
v p: R
p = ofN: ℕ → ℕ∪∞
ofN 1: ?m.1079
1
  v_mul_eq_add_v: ∀ {R : Type u} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a b : R),
  SurjVal.v self (a * b) = SurjVal.v self a + SurjVal.v self b
v_mul_eq_add_v (a: R
a b: R
b : R: Type u
R) : v: R → ℕ∪∞
v (a: R
a * b: R
b) = v: R → ℕ∪∞
v a: R
a + v: R → ℕ∪∞
v b: R
b
  v_add_ge_min_v: ∀ {R : Type u} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a b : R),
  SurjVal.v self (a + b) ≥ min (SurjVal.v self a) (SurjVal.v self b)
v_add_ge_min_v (a: R
a b: R
b : R: Type u
R) : v: R → ℕ∪∞
v (a: R
a + b: R
b) ≥ min: {α : Type ?u.1326} → [self : Min α] → α → α → α
min (v: R → ℕ∪∞
v a: R
a) (v: R → ℕ∪∞
v b: R
b)
  v_eq_top_iff_zero: ∀ {R : Type u} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a : R), SurjVal.v self a = ∞ ↔ a = 0
v_eq_top_iff_zero (a: R
a : R: Type u
R) : v: R → ℕ∪∞
v a: R
a = ∞: ℕ∪∞
∞ ↔ a: R
a = 0: ?m.1352
0

variable {R: Type u
R : Type u: Type (u + 1)
Type u} [IntegralDomain: Type ?u.2056 → Type ?u.2056
IntegralDomain R: Type u
R]

section SurjVal

lemma p_non_zero: ∀ {R : Type u} [inst : IntegralDomain R] {p : R}, SurjVal p → ¬p = 0
p_non_zero {p: R
p : R: Type u
R} (nav: SurjVal p
nav : SurjVal: {R : Type ?u.2061} → R → [inst : IntegralDomain R] → Type ?u.2061
SurjVal p: R
p) : ¬p: R
p = 0: ?m.2071
0 := by
  R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

¬p = 0rw [R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

¬p = 0←nav: SurjVal p
nav.v_eq_top_iff_zero: ∀ {R : Type ?u.2143} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a : R), SurjVal.v self a = ∞ ↔ a = 0
v_eq_top_iff_zero,R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

¬SurjVal.v nav p = ∞ R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

¬p = 0nav: SurjVal p
nav.v_uniformizer: ∀ {R : Type ?u.2158} {p : R} [inst : IntegralDomain R] (self : SurjVal p), SurjVal.v self p = ofN 1
v_uniformizerR: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

¬ofN 1 = ∞]R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

¬ofN 1 = ∞
  R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

¬p = 0simp
Goals accomplished! 🐙

@[simp]
lemma val_zero: ∀ {p : R} (nav : SurjVal p), SurjVal.v nav 0 = ∞
val_zero {p: R
p : R: Type u
R} (nav: SurjVal p
nav : SurjVal: {R : Type ?u.2231} → R → [inst : IntegralDomain R] → Type ?u.2231
SurjVal p: R
p) : nav: SurjVal p
nav.v: {R : Type ?u.2240} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v 0: ?m.2248
0 = ∞: ℕ∪∞
∞ := (nav: SurjVal p
nav.v_eq_top_iff_zero: ∀ {R : Type ?u.2303} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a : R), SurjVal.v self a = ∞ ↔ a = 0
v_eq_top_iff_zero 0: ?m.2308
0).2: ∀ {a b : Prop}, (a ↔ b) → b → a
2 rfl: ∀ {α : Sort ?u.2314} {a : α}, a = a
rfl

lemma val_mul_ge_left: ∀ {R : Type u} [inst : IntegralDomain R] {p : R} (nav : SurjVal p) (a b : R), SurjVal.v nav (a * b) ≥ SurjVal.v nav a
val_mul_ge_left {p: R
p : R: Type u
R} (nav: SurjVal p
nav : SurjVal: {R : Type ?u.2340} → R → [inst : IntegralDomain R] → Type ?u.2340
SurjVal p: R
p) (a: R
a b: R
b : R: Type u
R) : nav: SurjVal p
nav.v: {R : Type ?u.2353} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (a: R
a * b: R
b) ≥ nav: SurjVal p
nav.v: {R : Type ?u.2453} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v a: R
a :=
Enat.le_trans: ∀ {n m k : ℕ∪∞}, n ≤ m → m ≤ k → n ≤ k
Enat.le_trans (le_add_right: ∀ (n k : ℕ∪∞), n ≤ n + k
le_add_right (nav: SurjVal p
nav.v: {R : Type ?u.2478} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v a: R
a) (nav: SurjVal p
nav.v: {R : Type ?u.2482} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v b: R
b)) (le_of_eq: ∀ {α : Type ?u.2486} [inst : Preorder α] {a b : α}, a = b → a ≤ b
le_of_eq (nav: SurjVal p
nav.v_mul_eq_add_v: ∀ {R : Type ?u.2493} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a b : R),
  SurjVal.v self (a * b) = SurjVal.v self a + SurjVal.v self b
v_mul_eq_add_v a: R
a b: R
b).symm: ∀ {α : Sort ?u.2497} {a b : α}, a = b → b = a
symm)

lemma val_mul_ge_right: ∀ {p : R} (nav : SurjVal p) (a b : R), SurjVal.v nav (a * b) ≥ SurjVal.v nav b
val_mul_ge_right {p: R
p : R: Type u
R} (nav: SurjVal p
nav : SurjVal: {R : Type ?u.2522} → R → [inst : IntegralDomain R] → Type ?u.2522
SurjVal p: R
p) (a: R
a b: R
b : R: Type u
R) : nav: SurjVal p
nav.v: {R : Type ?u.2535} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (a: R
a * b: R
b) ≥ nav: SurjVal p
nav.v: {R : Type ?u.2635} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v b: R
b := by
  R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

SurjVal.v nav (a * b) ≥ SurjVal.v nav brw [R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

SurjVal.v nav (a * b) ≥ SurjVal.v nav bmul_comm: ∀ {G : Type ?u.2655} [inst : CommSemigroup G] (a b : G), a * b = b * a
mul_commR: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

SurjVal.v nav (b * a) ≥ SurjVal.v nav b]R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

SurjVal.v nav (b * a) ≥ SurjVal.v nav b
  R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

SurjVal.v nav (a * b) ≥ SurjVal.v nav bexact val_mul_ge_left: ∀ {R : Type ?u.2729} [inst : IntegralDomain R] {p : R} (nav : SurjVal p) (a b : R),
  SurjVal.v nav (a * b) ≥ SurjVal.v nav a
val_mul_ge_left nav: SurjVal p
nav b: R
b a: R
a
Goals accomplished! 🐙

lemma val_mul_ge_of_left_ge: ∀ {n : ℕ∪∞} {p : R} (nav : SurjVal p) {a b : R}, SurjVal.v nav a ≥ n → SurjVal.v nav (a * b) ≥ n
val_mul_ge_of_left_ge {p: R
p : R: Type u
R} (nav: SurjVal p
nav : SurjVal: {R : Type ?u.2786} → R → [inst : IntegralDomain R] → Type ?u.2786
SurjVal p: R
p) {a: R
a b: R
b : R: Type u
R} (ha: SurjVal.v nav a ≥ n
ha : nav: SurjVal p
nav.v: {R : Type ?u.2796} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v a: R
a ≥ n: ?m.2781
n) : nav: SurjVal p
nav.v: {R : Type ?u.2808} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (a: R
a * b: R
b) ≥ n: ?m.2781
n :=
Enat.le_trans: ∀ {n m k : ℕ∪∞}, n ≤ m → m ≤ k → n ≤ k
Enat.le_trans ha: SurjVal.v nav a ≥ n
ha (val_mul_ge_left: ∀ {R : Type ?u.2927} [inst : IntegralDomain R] {p : R} (nav : SurjVal p) (a b : R),
  SurjVal.v nav (a * b) ≥ SurjVal.v nav a
val_mul_ge_left nav: SurjVal p
nav a: R
a b: R
b)

lemma val_mul_ge_of_right_ge: ∀ {n : ℕ∪∞} {p : R} (nav : SurjVal p) {a b : R}, SurjVal.v nav b ≥ n → SurjVal.v nav (a * b) ≥ n
val_mul_ge_of_right_ge {p: R
p : R: Type u
R} (nav: SurjVal p
nav : SurjVal: {R : Type ?u.2950} → R → [inst : IntegralDomain R] → Type ?u.2950
SurjVal p: R
p) {a: R
a b: R
b : R: Type u
R} (hb: SurjVal.v nav b ≥ n
hb : nav: SurjVal p
nav.v: {R : Type ?u.2986} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v b: R
b ≥ n: ?m.2971
n) : nav: SurjVal p
nav.v: {R : Type ?u.2998} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (a: R
a * b: R
b) ≥ n: ?m.2971
n :=
Enat.le_trans: ∀ {n m k : ℕ∪∞}, n ≤ m → m ≤ k → n ≤ k
Enat.le_trans hb: SurjVal.v nav b ≥ n
hb (val_mul_ge_right: ∀ {R : Type ?u.3117} [inst : IntegralDomain R] {p : R} (nav : SurjVal p) (a b : R),
  SurjVal.v nav (a * b) ≥ SurjVal.v nav b
val_mul_ge_right nav: SurjVal p
nav a: R
a b: R
b)

lemma val_mul_ge_of_both_ge: ∀ {m n : ℕ∪∞} {p : R} (nav : SurjVal p) {a b : R},
  SurjVal.v nav a ≥ m → SurjVal.v nav b ≥ n → SurjVal.v nav (a * b) ≥ m + n
val_mul_ge_of_both_ge {p: R
p : R: Type u
R} (nav: SurjVal p
nav : SurjVal: {R : Type ?u.3198} → R → [inst : IntegralDomain R] → Type ?u.3198
SurjVal p: R
p) {a: R
a b: R
b : R: Type u
R} (ha: SurjVal.v nav a ≥ m
ha : nav: SurjVal p
nav.v: {R : Type ?u.3208} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v a: R
a ≥ m: ?m.3161
m) (hb: SurjVal.v nav b ≥ n
hb : nav: SurjVal p
nav.v: {R : Type ?u.3217} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v b: R
b ≥ n: ?m.3193
n) :
nav: SurjVal p
nav.v: {R : Type ?u.3226} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (a: R
a * b: R
b) ≥ m: ?m.3161
m + n: ?m.3193
n := by
  R: Type u

inst✝: IntegralDomain R

m, n: ℕ∪∞

p: R

nav: SurjVal p

a, b: R

ha: SurjVal.v nav a ≥ m

hb: SurjVal.v nav b ≥ n

SurjVal.v nav (a * b) ≥ m + nrw [R: Type u

inst✝: IntegralDomain R

m, n: ℕ∪∞

p: R

nav: SurjVal p

a, b: R

ha: SurjVal.v nav a ≥ m

hb: SurjVal.v nav b ≥ n

SurjVal.v nav (a * b) ≥ m + nnav: SurjVal p
nav.v_mul_eq_add_v: ∀ {R : Type ?u.3384} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a b : R),
  SurjVal.v self (a * b) = SurjVal.v self a + SurjVal.v self b
v_mul_eq_add_vR: Type u

inst✝: IntegralDomain R

m, n: ℕ∪∞

p: R

nav: SurjVal p

a, b: R

ha: SurjVal.v nav a ≥ m

hb: SurjVal.v nav b ≥ n

SurjVal.v nav a + SurjVal.v nav b ≥ m + n]R: Type u

inst✝: IntegralDomain R

m, n: ℕ∪∞

p: R

nav: SurjVal p

a, b: R

ha: SurjVal.v nav a ≥ m

hb: SurjVal.v nav b ≥ n

SurjVal.v nav a + SurjVal.v nav b ≥ m + n
  R: Type u

inst✝: IntegralDomain R

m, n: ℕ∪∞

p: R

nav: SurjVal p

a, b: R

ha: SurjVal.v nav a ≥ m

hb: SurjVal.v nav b ≥ n

SurjVal.v nav (a * b) ≥ m + napply add_le_add: ∀ {a b c d : ℕ∪∞}, a ≤ b → c ≤ d → a + c ≤ b + d
add_le_add ha: SurjVal.v nav a ≥ m
ha hb: SurjVal.v nav b ≥ n
hb
Goals accomplished! 🐙

@[simp]
lemma val_of_one: ∀ {p : R} (nav : SurjVal p), SurjVal.v nav 1 = ofN 0
val_of_one {p: R
p : R: Type u
R} (nav: SurjVal p
nav : SurjVal: {R : Type ?u.3442} → R → [inst : IntegralDomain R] → Type ?u.3442
SurjVal p: R
p) : nav: SurjVal p
nav.v: {R : Type ?u.3451} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v 1: ?m.3459
1 = ofN: ℕ → ℕ∪∞
ofN 0: ?m.3511
0 := by
  R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

SurjVal.v nav 1 = ofN 0apply Enat.add_right_cancel_ofN: ∀ (a : ℕ) (b c : ℕ∪∞), b + ofN a = c + ofN a → b = c
Enat.add_right_cancel_ofN 1: ?m.3528
1R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

aSurjVal.v nav 1 + ofN 1 = ofN 0 + ofN 1
  R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

SurjVal.v nav 1 = ofN 0rw [R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

aSurjVal.v nav 1 + ofN 1 = ofN 0 + ofN 1add_ofN: ∀ (a b : ℕ), ofN a + ofN b = ofN (a + b)
add_ofN,R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

aSurjVal.v nav 1 + ofN 1 = ofN (0 + 1) R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

aSurjVal.v nav 1 + ofN 1 = ofN 0 + ofN 1←SurjVal.v_uniformizer: ∀ {R : Type ?u.3566} {p : R} [inst : IntegralDomain R] (self : SurjVal p), SurjVal.v self p = ofN 1
SurjVal.v_uniformizer nav: SurjVal p
nav,R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

aSurjVal.v nav 1 + SurjVal.v nav p = SurjVal.v nav p R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

aSurjVal.v nav 1 + ofN 1 = ofN 0 + ofN 1←SurjVal.v_mul_eq_add_v: ∀ {R : Type ?u.3576} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a b : R),
  SurjVal.v self (a * b) = SurjVal.v self a + SurjVal.v self b
SurjVal.v_mul_eq_add_v nav: SurjVal p
nav,R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

aSurjVal.v nav (1 * p) = SurjVal.v nav p R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

aSurjVal.v nav 1 + ofN 1 = ofN 0 + ofN 1one_mul: ∀ {M : Type ?u.3595} [inst : MulOneClass M] (a : M), 1 * a = a
one_mulR: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

aSurjVal.v nav p = SurjVal.v nav p]
Goals accomplished! 🐙

lemma val_pow_ge_of_ge: ∀ {R : Type u} [inst : IntegralDomain R] {m : ℕ∪∞} {p : R} (nav : SurjVal p) {a : R} (k : ℕ),
  SurjVal.v nav a ≥ m → SurjVal.v nav (a ^ k) ≥ k • m
val_pow_ge_of_ge {p: R
p : R: Type u
R} (nav: SurjVal p
nav : SurjVal: {R : Type ?u.3719} → R → [inst : IntegralDomain R] → Type ?u.3719
SurjVal p: R
p) {a: R
a : R: Type u
R} (k: ℕ
k : ℕ: Type
ℕ) (ha: SurjVal.v nav a ≥ m
ha : nav: SurjVal p
nav.v: {R : Type ?u.3755} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v a: R
a ≥ m: ?m.3740
m) :
nav: SurjVal p
nav.v: {R : Type ?u.3767} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (a: R
a ^ k: ℕ
k) ≥ k: ℕ
k • m: ?m.3740
m := by
  R: Type u

inst✝: IntegralDomain R

m: ℕ∪∞

p: R

nav: SurjVal p

a: R

k: ℕ

ha: SurjVal.v nav a ≥ m

SurjVal.v nav (a ^ k) ≥ k • minduction k: ℕ
k with
  R: Type u

inst✝: IntegralDomain R

m: ℕ∪∞

p: R

nav: SurjVal p

a: R

k: ℕ

ha: SurjVal.v nav a ≥ m

SurjVal.v nav (a ^ k) ≥ k • m| zero: ℕ
zero => R: Type u

inst✝: IntegralDomain R

m: ℕ∪∞

p: R

nav: SurjVal p

a: R

ha: SurjVal.v nav a ≥ m

zeroSurjVal.v nav (a ^ Nat.zero) ≥ Nat.zero • msimp [zero_nsmul: ∀ {M : Type ?u.4082} [inst : AddMonoid M] (a : M), 0 • a = 0
zero_nsmul]
Goals accomplished! 🐙 -- TODO why isn't this simp?
  R: Type u

inst✝: IntegralDomain R

m: ℕ∪∞

p: R

nav: SurjVal p

a: R

k: ℕ

ha: SurjVal.v nav a ≥ m

SurjVal.v nav (a ^ k) ≥ k • m| succ: ℕ → ℕ
succ k: ℕ
k ih: ?m.4076 k
ih =>
    R: Type u

inst✝: IntegralDomain R

m: ℕ∪∞

p: R

nav: SurjVal p

a: R

ha: SurjVal.v nav a ≥ m

k: ℕ

ih: SurjVal.v nav (a ^ k) ≥ k • m

succSurjVal.v nav (a ^ Nat.succ k) ≥ Nat.succ k • msimp [succ_nsmul: ∀ {M : Type ?u.4450} [inst : AddMonoid M] (a : M) (n : ℕ), (n + 1) • a = a + n • a
succ_nsmul, pow_succ: ∀ {M : Type ?u.4460} [inst : Monoid M] (a : M) (n : ℕ), a ^ (n + 1) = a * a ^ n
pow_succ]R: Type u

inst✝: IntegralDomain R

m: ℕ∪∞

p: R

nav: SurjVal p

a: R

ha: SurjVal.v nav a ≥ m

k: ℕ

ih: SurjVal.v nav (a ^ k) ≥ k • m

succSurjVal.v nav (a * a ^ k) ≥ m + k • m
    R: Type u

inst✝: IntegralDomain R

m: ℕ∪∞

p: R

nav: SurjVal p

a: R

ha: SurjVal.v nav a ≥ m

k: ℕ

ih: SurjVal.v nav (a ^ k) ≥ k • m

succSurjVal.v nav (a ^ Nat.succ k) ≥ Nat.succ k • mapply val_mul_ge_of_both_ge: ∀ {R : Type ?u.4718} [inst : IntegralDomain R] {m n : ℕ∪∞} {p : R} (nav : SurjVal p) {a b : R},
  SurjVal.v nav a ≥ m → SurjVal.v nav b ≥ n → SurjVal.v nav (a * b) ≥ m + n
val_mul_ge_of_both_ge _: SurjVal ?m.4723
_ ha: SurjVal.v nav a ≥ m
ha ih: ?m.4076 k
ih
Goals accomplished! 🐙

lemma val_add_ge_of_ge: ∀ {R : Type u} [inst : IntegralDomain R] {n : ℕ∪∞} {p : R} (nav : SurjVal p) {a b : R},
  SurjVal.v nav a ≥ n → SurjVal.v nav b ≥ n → SurjVal.v nav (a + b) ≥ n
val_add_ge_of_ge {p: R
p : R: Type u
R} (nav: SurjVal p
nav : SurjVal: {R : Type ?u.4790} → R → [inst : IntegralDomain R] → Type ?u.4790
SurjVal p: R
p) {a: R
a b: R
b : R: Type u
R} (ha: SurjVal.v nav a ≥ n
ha : nav: SurjVal p
nav.v: {R : Type ?u.4800} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v a: R
a ≥ n: ?m.4785
n) (hb: SurjVal.v nav b ≥ n
hb : nav: SurjVal p
nav.v: {R : Type ?u.4812} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v b: R
b ≥ n: ?m.4785
n) :
nav: SurjVal p
nav.v: {R : Type ?u.4821} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (a: R
a + b: R
b) ≥ n: ?m.4785
n := Enat.le_trans: ∀ {n m k : ℕ∪∞}, n ≤ m → m ≤ k → n ≤ k
Enat.le_trans (le_min: ∀ {α : Type ?u.4946} [inst : LinearOrder α] {a b c : α}, c ≤ a → c ≤ b → c ≤ min a b
le_min ha: SurjVal.v nav a ≥ n
ha hb: SurjVal.v nav b ≥ n
hb) (nav: SurjVal p
nav.v_add_ge_min_v: ∀ {R : Type ?u.4953} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a b : R),
  SurjVal.v self (a + b) ≥ min (SurjVal.v self a) (SurjVal.v self b)
v_add_ge_min_v a: R
a b: R
b)

def nat_of_val: {p : R} → SurjVal p → {a : R} → a ≠ 0 → ℕ
nat_of_val {p: R
p : R: Type u
R} (nav: SurjVal p
nav : SurjVal: {R : Type ?u.4974} → R → [inst : IntegralDomain R] → Type ?u.4974
SurjVal p: R
p) {a: R
a : R: Type u
R} (h: a ≠ 0
h : a: R
a ≠ 0: ?m.4987
0) : ℕ: Type
ℕ :=
  to_nat: {a : ℕ∪∞} → a ≠ ∞ → ℕ
to_nat ((not_iff_not: ∀ {a b : Prop}, (¬a ↔ ¬b) ↔ (a ↔ b)
not_iff_not.2: ∀ {a b : Prop}, (a ↔ b) → b → a
2 (nav: SurjVal p
nav.v_eq_top_iff_zero: ∀ {R : Type ?u.5052} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a : R), SurjVal.v self a = ∞ ↔ a = 0
v_eq_top_iff_zero a: R
a)).2: ∀ {a b : Prop}, (a ↔ b) → b → a
2 h: a ≠ 0
h)

/-
lemma val_of_add_one {p : R} (nav : SurjVal p) (h : nav.v x ≥ ofN 1): nav.v (x + 1) = ofN 0 := by
  apply Enat.le_antisymm
  . apply le_of_not_lt
    intro h'
    sorry
  . apply Enat.le_trans _ (nav.v_add_ge_min_v x 1)
    apply le_min (Enat.le_trans (Enat.le_succ 0) h) (le_of_eq (val_of_one nav).symm)
-/

@[simp]
lemma val_of_minus_one: ∀ {R : Type u} [inst : IntegralDomain R] {p : R} (nav : SurjVal p), SurjVal.v nav (-1) = ofN 0
val_of_minus_one {p: R
p : R: Type u
R} (nav: SurjVal p
nav : SurjVal: {R : Type ?u.5146} → R → [inst : IntegralDomain R] → Type ?u.5146
SurjVal p: R
p) : nav: SurjVal p
nav.v: {R : Type ?u.5155} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (-1: ?m.5164
1) = ofN: ℕ → ℕ∪∞
ofN 0: ?m.5247
0 := by
  R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

SurjVal.v nav (-1) = ofN 0cases eq_zero_or_pos: ∀ (n : ℕ∪∞), n = ofN 0 ∨ n > ofN 0
eq_zero_or_pos (nav: SurjVal p
nav.v: {R : Type ?u.5263} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (-1: ?m.5269
1)) with
  R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

x✝: SurjVal.v nav (-1) = ofN 0 ∨ SurjVal.v nav (-1) > ofN 0

SurjVal.v nav (-1) = ofN 0| inl: ∀ {a b : Prop}, a → a ∨ b
inl h: ?m.5307
h => R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) = ofN 0

inlSurjVal.v nav (-1) = ofN 0exact h: ?m.5307
h
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

x✝: SurjVal.v nav (-1) = ofN 0 ∨ SurjVal.v nav (-1) > ofN 0

SurjVal.v nav (-1) = ofN 0| inr: ∀ {a b : Prop}, b → a ∨ b
inr h: ?m.5308
h =>
    R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

inrSurjVal.v nav (-1) = ofN 0have contradiction: SurjVal.v nav 1 > ofN 0
contradiction : nav: SurjVal p
nav.v: {R : Type ?u.5354} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v 1: ?m.5359
1 > ofN: ℕ → ℕ∪∞
ofN 0: ?m.5362
0 := R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

inrSurjVal.v nav (-1) = ofN 0by
      R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

SurjVal.v nav 1 > ofN 0rw [R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

SurjVal.v nav 1 > ofN 0←neg_neg: ∀ {G : Type ?u.5373} [inst : HasInvolutiveNeg G] (a : G), - -a = a
neg_neg 1: ?m.5377
1,R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

SurjVal.v nav (- -1) > ofN 0 R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

SurjVal.v nav 1 > ofN 0←one_mul: ∀ {M : Type ?u.5477} [inst : MulOneClass M] (a : M), 1 * a = a
one_mul 1: ?m.5481
1,R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

SurjVal.v nav (- -(1 * 1)) > ofN 0 R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

SurjVal.v nav 1 > ofN 0neg_mul_left: ∀ {R : Type ?u.5574} [inst : Ring R] (a b : R), -(a * b) = -a * b
neg_mul_left,R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

SurjVal.v nav (-(-1 * 1)) > ofN 0 R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

SurjVal.v nav 1 > ofN 0neg_mul_right: ∀ {R : Type ?u.5645} [inst : Ring R] (a b : R), -(a * b) = a * -b
neg_mul_right,R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

SurjVal.v nav (-1 * -1) > ofN 0 R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

SurjVal.v nav 1 > ofN 0nav: SurjVal p
nav.v_mul_eq_add_v: ∀ {R : Type ?u.5669} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a b : R),
  SurjVal.v self (a * b) = SurjVal.v self a + SurjVal.v self b
v_mul_eq_add_vR: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

SurjVal.v nav (-1) + SurjVal.v nav (-1) > ofN 0]R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

SurjVal.v nav (-1) + SurjVal.v nav (-1) > ofN 0
      R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

SurjVal.v nav 1 > ofN 0apply lt_add_right: ∀ (a b c : ℕ∪∞), a < b → a < b + c
lt_add_right _: ℕ∪∞
_ _: ℕ∪∞
_ _: ℕ∪∞
_ h: SurjVal.v nav (-1) > ofN 0
h
Goals accomplished! 🐙
    R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

inrSurjVal.v nav (-1) = ofN 0rw [R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

contradiction: SurjVal.v nav 1 > ofN 0

inrSurjVal.v nav (-1) = ofN 0val_of_one: ∀ {R : Type ?u.5712} [inst : IntegralDomain R] {p : R} (nav : SurjVal p), SurjVal.v nav 1 = ofN 0
val_of_oneR: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

contradiction: ofN 0 > ofN 0

inrSurjVal.v nav (-1) = ofN 0]R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

contradiction: ofN 0 > ofN 0

inrSurjVal.v nav (-1) = ofN 0 at contradiction: SurjVal.v nav 1 > ofN 0
contradictionR: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

contradiction: ofN 0 > ofN 0

inrSurjVal.v nav (-1) = ofN 0
    R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

inrSurjVal.v nav (-1) = ofN 0exact False.elim: ∀ {C : Sort ?u.5742}, False → C
False.elim ((lt_irrefl: ∀ {α : Type ?u.5744} [inst : Preorder α] (a : α), ¬a < a
lt_irrefl (ofN: ℕ → ℕ∪∞
ofN 0: ?m.5748
0)) contradiction: ofN 0 > ofN 0
contradiction)
Goals accomplished! 🐙

@[simp]
lemma val_neg: ∀ {x p : R} (nav : SurjVal p), SurjVal.v nav (-x) = SurjVal.v nav x
val_neg {p: R
p : R: Type u
R} (nav: SurjVal p
nav : SurjVal: {R : Type ?u.5788} → R → [inst : IntegralDomain R] → Type ?u.5788
SurjVal p: R
p) : nav: SurjVal p
nav.v: {R : Type ?u.5817} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (-x: ?m.5806
x) = nav: SurjVal p
nav.v: {R : Type ?u.5845} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: ?m.5806
x := by
  R: Type u

inst✝: IntegralDomain R

x, p: R

nav: SurjVal p

SurjVal.v nav (-x) = SurjVal.v nav xrw [R: Type u

inst✝: IntegralDomain R

x, p: R

nav: SurjVal p

SurjVal.v nav (-x) = SurjVal.v nav x←one_mul: ∀ {M : Type ?u.5856} [inst : MulOneClass M] (a : M), 1 * a = a
one_mul x: R
x,R: Type u

inst✝: IntegralDomain R

x, p: R

nav: SurjVal p

SurjVal.v nav (-(1 * x)) = SurjVal.v nav (1 * x) R: Type u

inst✝: IntegralDomain R

x, p: R

nav: SurjVal p

SurjVal.v nav (-x) = SurjVal.v nav xneg_mul_left: ∀ {R : Type ?u.5892} [inst : Ring R] (a b : R), -(a * b) = -a * b
neg_mul_left,R: Type u

inst✝: IntegralDomain R

x, p: R

nav: SurjVal p

SurjVal.v nav (-1 * x) = SurjVal.v nav (1 * x) R: Type u

inst✝: IntegralDomain R

x, p: R

nav: SurjVal p

SurjVal.v nav (-x) = SurjVal.v nav xnav: SurjVal p
nav.v_mul_eq_add_v: ∀ {R : Type ?u.5944} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a b : R),
  SurjVal.v self (a * b) = SurjVal.v self a + SurjVal.v self b
v_mul_eq_add_v,R: Type u

inst✝: IntegralDomain R

x, p: R

nav: SurjVal p

SurjVal.v nav (-1) + SurjVal.v nav x = SurjVal.v nav (1 * x) R: Type u

inst✝: IntegralDomain R

x, p: R

nav: SurjVal p

SurjVal.v nav (-x) = SurjVal.v nav xval_of_minus_one: ∀ {R : Type ?u.5964} [inst : IntegralDomain R] {p : R} (nav : SurjVal p), SurjVal.v nav (-1) = ofN 0
val_of_minus_one,R: Type u

inst✝: IntegralDomain R

x, p: R

nav: SurjVal p

ofN 0 + SurjVal.v nav x = SurjVal.v nav (1 * x) R: Type u

inst✝: IntegralDomain R

x, p: R

nav: SurjVal p

SurjVal.v nav (-x) = SurjVal.v nav xone_mul: ∀ {M : Type ?u.5987} [inst : MulOneClass M] (a : M), 1 * a = a
one_mul,R: Type u

inst✝: IntegralDomain R

x, p: R

nav: SurjVal p

ofN 0 + SurjVal.v nav x = SurjVal.v nav x R: Type u

inst✝: IntegralDomain R

x, p: R

nav: SurjVal p

SurjVal.v nav (-x) = SurjVal.v nav xEnat.zero_add: ∀ (a : ℕ∪∞), ofN 0 + a = a
Enat.zero_addR: Type u

inst✝: IntegralDomain R

x, p: R

nav: SurjVal p

SurjVal.v nav x = SurjVal.v nav x]
Goals accomplished! 🐙

lemma val_sub_ge_of_ge: ∀ {R : Type u} [inst : IntegralDomain R] {n : ℕ∪∞} {p : R} (nav : SurjVal p) {a b : R},
  SurjVal.v nav a ≥ n → SurjVal.v nav b ≥ n → SurjVal.v nav (a - b) ≥ n
val_sub_ge_of_ge {p: R
p : R: Type u
R} (nav: SurjVal p
nav : SurjVal: {R : Type ?u.6115} → R → [inst : IntegralDomain R] → Type ?u.6115
SurjVal p: R
p) {a: R
a b: R
b : R: Type u
R} (ha: SurjVal.v nav a ≥ n
ha : nav: SurjVal p
nav.v: {R : Type ?u.6125} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v a: R
a ≥ n: ?m.6110
n) (hb: SurjVal.v nav b ≥ n
hb : nav: SurjVal p
nav.v: {R : Type ?u.6137} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v b: R
b ≥ n: ?m.6110
n) :
nav: SurjVal p
nav.v: {R : Type ?u.6146} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (a: R
a - b: R
b) ≥ n: ?m.6110
n := by
  R: Type u

inst✝: IntegralDomain R

n: ℕ∪∞

p: R

nav: SurjVal p

a, b: R

ha: SurjVal.v nav a ≥ n

hb: SurjVal.v nav b ≥ n

SurjVal.v nav (a - b) ≥ nrw [R: Type u

inst✝: IntegralDomain R

n: ℕ∪∞

p: R

nav: SurjVal p

a, b: R

ha: SurjVal.v nav a ≥ n

hb: SurjVal.v nav b ≥ n

SurjVal.v nav (a - b) ≥ nsub_eq_add_neg: ∀ {G : Type ?u.6230} [inst : SubNegMonoid G] (a b : G), a - b = a + -b
sub_eq_add_negR: Type u

inst✝: IntegralDomain R

n: ℕ∪∞

p: R

nav: SurjVal p

a, b: R

ha: SurjVal.v nav a ≥ n

hb: SurjVal.v nav b ≥ n

SurjVal.v nav (a + -b) ≥ n]R: Type u

inst✝: IntegralDomain R

n: ℕ∪∞

p: R

nav: SurjVal p

a, b: R

ha: SurjVal.v nav a ≥ n

hb: SurjVal.v nav b ≥ n

SurjVal.v nav (a + -b) ≥ n
  R: Type u

inst✝: IntegralDomain R

n: ℕ∪∞

p: R

nav: SurjVal p

a, b: R

ha: SurjVal.v nav a ≥ n

hb: SurjVal.v nav b ≥ n

SurjVal.v nav (a - b) ≥ napply val_add_ge_of_ge: ∀ {R : Type ?u.6335} [inst : IntegralDomain R] {n : ℕ∪∞} {p : R} (nav : SurjVal p) {a b : R},
  SurjVal.v nav a ≥ n → SurjVal.v nav b ≥ n → SurjVal.v nav (a + b) ≥ n
val_add_ge_of_geR: Type u

inst✝: IntegralDomain R

n: ℕ∪∞

p: R

nav: SurjVal p

a, b: R

ha: SurjVal.v nav a ≥ n

hb: SurjVal.v nav b ≥ n

haSurjVal.v nav a ≥ n
R: Type u

inst✝: IntegralDomain R

n: ℕ∪∞

p: R

nav: SurjVal p

a, b: R

ha: SurjVal.v nav a ≥ n

hb: SurjVal.v nav b ≥ n

hbSurjVal.v nav (-b) ≥ n
  R: Type u

inst✝: IntegralDomain R

n: ℕ∪∞

p: R

nav: SurjVal p

a, b: R

ha: SurjVal.v nav a ≥ n

hb: SurjVal.v nav b ≥ n

SurjVal.v nav (a - b) ≥ nassumptionR: Type u

inst✝: IntegralDomain R

n: ℕ∪∞

p: R

nav: SurjVal p

a, b: R

ha: SurjVal.v nav a ≥ n

hb: SurjVal.v nav b ≥ n

hbSurjVal.v nav (-b) ≥ n
  R: Type u

inst✝: IntegralDomain R

n: ℕ∪∞

p: R

nav: SurjVal p

a, b: R

ha: SurjVal.v nav a ≥ n

hb: SurjVal.v nav b ≥ n

SurjVal.v nav (a - b) ≥ nsimpa
Goals accomplished! 🐙

theorem v_add_eq_min_v: ∀ {p : R} (nav : SurjVal p) {a b : R}, SurjVal.v nav a < SurjVal.v nav b → SurjVal.v nav (a + b) = SurjVal.v nav a
v_add_eq_min_v {p: R
p : R: Type u
R} (nav: SurjVal p
nav : SurjVal: {R : Type ?u.6665} → R → [inst : IntegralDomain R] → Type ?u.6665
SurjVal p: R
p) {a: R
a b: R
b : R: Type u
R} (h: SurjVal.v nav a < SurjVal.v nav b
h : nav: SurjVal p
nav.v: {R : Type ?u.6678} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v a: R
a < nav: SurjVal p
nav.v: {R : Type ?u.6685} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v b: R
b) :
  nav: SurjVal p
nav.v: {R : Type ?u.6697} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (a: R
a + b: R
b) = nav: SurjVal p
nav.v: {R : Type ?u.6798} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v a: R
a := by
  R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

SurjVal.v nav (a + b) = SurjVal.v nav aapply Enat.le_antisymm: ∀ {n m : ℕ∪∞}, n ≤ m → m ≤ n → n = m
Enat.le_antisymmR: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h1SurjVal.v nav (a + b) ≤ SurjVal.v nav a
R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h2SurjVal.v nav a ≤ SurjVal.v nav (a + b)
  R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

SurjVal.v nav (a + b) = SurjVal.v nav a.R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h1SurjVal.v nav (a + b) ≤ SurjVal.v nav a R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h1SurjVal.v nav (a + b) ≤ SurjVal.v nav a
R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h2SurjVal.v nav a ≤ SurjVal.v nav (a + b)apply le_of_not_lt: ∀ {α : Type ?u.6822} [inst : LinearOrder α] {a b : α}, ¬b < a → a ≤ b
le_of_not_ltR: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h1.h¬SurjVal.v nav a < SurjVal.v nav (a + b)
    R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h1SurjVal.v nav (a + b) ≤ SurjVal.v nav a
R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h2SurjVal.v nav a ≤ SurjVal.v nav (a + b)intro h': SurjVal.v nav a < SurjVal.v nav (a + b)
h'R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h': SurjVal.v nav a < SurjVal.v nav (a + b)

h1.hFalse
    R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h1SurjVal.v nav (a + b) ≤ SurjVal.v nav a
R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h2SurjVal.v nav a ≤ SurjVal.v nav (a + b)have hm: SurjVal.v nav a < SurjVal.v nav (-b)
hm : nav: SurjVal p
nav.v: {R : Type ?u.6843} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v a: R
a < nav: SurjVal p
nav.v: {R : Type ?u.6847} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (-b: R
b) := R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h': SurjVal.v nav a < SurjVal.v nav (a + b)

h1.hFalseby R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h': SurjVal.v nav a < SurjVal.v nav (a + b)

SurjVal.v nav a < SurjVal.v nav (-b)rwa [R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h': SurjVal.v nav a < SurjVal.v nav (a + b)

SurjVal.v nav a < SurjVal.v nav (-b)val_neg: ∀ {R : Type ?u.6876} [inst : IntegralDomain R] {x p : R} (nav : SurjVal p), SurjVal.v nav (-x) = SurjVal.v nav x
val_negR: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h': SurjVal.v nav a < SurjVal.v nav (a + b)

SurjVal.v nav a < SurjVal.v nav b]R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h': SurjVal.v nav a < SurjVal.v nav (a + b)

SurjVal.v nav a < SurjVal.v nav b
    R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h1SurjVal.v nav (a + b) ≤ SurjVal.v nav a
R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h2SurjVal.v nav a ≤ SurjVal.v nav (a + b)apply lt_irrefl: ∀ {α : Type ?u.6916} [inst : Preorder α] (a : α), ¬a < a
lt_irrefl (nav: SurjVal p
nav.v: {R : Type ?u.6919} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v a: R
a)R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h': SurjVal.v nav a < SurjVal.v nav (a + b)

hm: SurjVal.v nav a < SurjVal.v nav (-b)

h1.hSurjVal.v nav a < SurjVal.v nav a
    R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h1SurjVal.v nav (a + b) ≤ SurjVal.v nav a
R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h2SurjVal.v nav a ≤ SurjVal.v nav (a + b)apply lt_of_lt_of_le: ∀ {α : Type ?u.6929} [inst : Preorder α] {a b c : α}, a < b → b ≤ c → a < c
lt_of_lt_of_le (lt_min: ∀ {α : Type ?u.6935} [inst : LinearOrder α] {a b c : α}, a < b → a < c → a < min b c
lt_min h': SurjVal.v nav a < SurjVal.v nav (a + b)
h' hm: SurjVal.v nav a < SurjVal.v nav (-b)
hm)R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h': SurjVal.v nav a < SurjVal.v nav (a + b)

hm: SurjVal.v nav a < SurjVal.v nav (-b)

h1.hmin (SurjVal.v nav (a + b)) (SurjVal.v nav (-b)) ≤ SurjVal.v nav a
    R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h1SurjVal.v nav (a + b) ≤ SurjVal.v nav a
R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h2SurjVal.v nav a ≤ SurjVal.v nav (a + b)rw [R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h': SurjVal.v nav a < SurjVal.v nav (a + b)

hm: SurjVal.v nav a < SurjVal.v nav (-b)

h1.hmin (SurjVal.v nav (a + b)) (SurjVal.v nav (-b)) ≤ SurjVal.v nav a(show nav: SurjVal p
nav.v: {R : Type ?u.6985} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v a: R
a = nav: SurjVal p
nav.v: {R : Type ?u.6989} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (a: R
a + b: R
b + -b: R
b) by R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h': SurjVal.v nav a < SurjVal.v nav (a + b)

hm: SurjVal.v nav a < SurjVal.v nav (-b)

h1.hmin (SurjVal.v nav (a + b)) (SurjVal.v nav (-b)) ≤ SurjVal.v nav asimp
Goals accomplished! 🐙)R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h': SurjVal.v nav a < SurjVal.v nav (a + b)

hm: SurjVal.v nav a < SurjVal.v nav (-b)

h1.hmin (SurjVal.v nav (a + b)) (SurjVal.v nav (-b)) ≤ SurjVal.v nav (a + b + -b)]R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h': SurjVal.v nav a < SurjVal.v nav (a + b)

hm: SurjVal.v nav a < SurjVal.v nav (-b)

h1.hmin (SurjVal.v nav (a + b)) (SurjVal.v nav (-b)) ≤ SurjVal.v nav (a + b + -b)
    R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h1SurjVal.v nav (a + b) ≤ SurjVal.v nav a
R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h2SurjVal.v nav a ≤ SurjVal.v nav (a + b)exact nav: SurjVal p
nav.v_add_ge_min_v: ∀ {R : Type ?u.7425} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a b : R),
  SurjVal.v self (a + b) ≥ min (SurjVal.v self a) (SurjVal.v self b)
v_add_ge_min_v (a: R
a + b: R
b) (-b: R
b)
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

SurjVal.v nav (a + b) = SurjVal.v nav a.R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h2SurjVal.v nav a ≤ SurjVal.v nav (a + b) R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h2SurjVal.v nav a ≤ SurjVal.v nav (a + b)exact Enat.le_trans: ∀ {n m k : ℕ∪∞}, n ≤ m → m ≤ k → n ≤ k
Enat.le_trans (le_min: ∀ {α : Type ?u.7485} [inst : LinearOrder α] {a b c : α}, c ≤ a → c ≤ b → c ≤ min a b
le_min (le_of_eq: ∀ {α : Type ?u.7491} [inst : Preorder α] {a b : α}, a = b → a ≤ b
le_of_eq rfl: ∀ {α : Sort ?u.7504} {a : α}, a = a
rfl) (Enat.le_of_lt: ∀ {n m : ℕ∪∞}, n < m → n ≤ m
Enat.le_of_lt h: SurjVal.v nav a < SurjVal.v nav b
h)) (SurjVal.v_add_ge_min_v: ∀ {R : Type ?u.7509} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a b : R),
  SurjVal.v self (a + b) ≥ min (SurjVal.v self a) (SurjVal.v self b)
SurjVal.v_add_ge_min_v nav: SurjVal p
nav a: R
a b: R
b)
Goals accomplished! 🐙

theorem val_of_pow_uniformizer: ∀ {n : ℕ} {p : R} (nav : SurjVal p), SurjVal.v nav (p ^ n) = ofN n
val_of_pow_uniformizer {p: R
p : R: Type u
R} (nav: SurjVal p
nav : SurjVal: {R : Type ?u.7561} → R → [inst : IntegralDomain R] → Type ?u.7561
SurjVal p: R
p) : nav: SurjVal p
nav.v: {R : Type ?u.7567} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (p: R
p ^ n: ?m.7556
n) = ofN: ℕ → ℕ∪∞
ofN n: ?m.7556
n := by
  R: Type u

inst✝: IntegralDomain R

n: ℕ

p: R

nav: SurjVal p

SurjVal.v nav (p ^ n) = ofN ninduction n: ℕ
n with
  R: Type u

inst✝: IntegralDomain R

n: ℕ

p: R

nav: SurjVal p

SurjVal.v nav (p ^ n) = ofN n| zero: ℕ
zero      =>
    R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

zeroSurjVal.v nav (p ^ Nat.zero) = ofN Nat.zerorw [R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

zeroSurjVal.v nav (p ^ Nat.zero) = ofN Nat.zeropow_zero: ∀ {M : Type ?u.7705} [inst : Monoid M] (a : M), a ^ 0 = 1
pow_zeroR: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

zeroSurjVal.v nav 1 = ofN Nat.zero]R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

zeroSurjVal.v nav 1 = ofN Nat.zero
    R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

zeroSurjVal.v nav (p ^ Nat.zero) = ofN Nat.zeroexact val_of_one: ∀ {R : Type ?u.7798} [inst : IntegralDomain R] {p : R} (nav : SurjVal p), SurjVal.v nav 1 = ofN 0
val_of_one nav: SurjVal p
nav
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

n: ℕ

p: R

nav: SurjVal p

SurjVal.v nav (p ^ n) = ofN n| succ: ℕ → ℕ
succ n: ℕ
n ih: ?m.7699 n
ih =>
    R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

n: ℕ

ih: SurjVal.v nav (p ^ n) = ofN n

succSurjVal.v nav (p ^ Nat.succ n) = ofN (Nat.succ n)rw [R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

n: ℕ

ih: SurjVal.v nav (p ^ n) = ofN n

succSurjVal.v nav (p ^ Nat.succ n) = ofN (Nat.succ n)pow_succ: ∀ {M : Type ?u.7819} [inst : Monoid M] (a : M) (n : ℕ), a ^ (n + 1) = a * a ^ n
pow_succ,R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

n: ℕ

ih: SurjVal.v nav (p ^ n) = ofN n

succSurjVal.v nav (p * p ^ n) = ofN (Nat.succ n) R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

n: ℕ

ih: SurjVal.v nav (p ^ n) = ofN n

succSurjVal.v nav (p ^ Nat.succ n) = ofN (Nat.succ n)SurjVal.v_mul_eq_add_v: ∀ {R : Type ?u.7877} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a b : R),
  SurjVal.v self (a * b) = SurjVal.v self a + SurjVal.v self b
SurjVal.v_mul_eq_add_v nav: SurjVal p
nav,R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

n: ℕ

ih: SurjVal.v nav (p ^ n) = ofN n

succSurjVal.v nav p + SurjVal.v nav (p ^ n) = ofN (Nat.succ n) R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

n: ℕ

ih: SurjVal.v nav (p ^ n) = ofN n

succSurjVal.v nav (p ^ Nat.succ n) = ofN (Nat.succ n)ih: ?m.7699 n
ih,R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

n: ℕ

ih: SurjVal.v nav (p ^ n) = ofN n

succSurjVal.v nav p + ofN n = ofN (Nat.succ n) R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

n: ℕ

ih: SurjVal.v nav (p ^ n) = ofN n

succSurjVal.v nav (p ^ Nat.succ n) = ofN (Nat.succ n)SurjVal.v_uniformizer: ∀ {R : Type ?u.7908} {p : R} [inst : IntegralDomain R] (self : SurjVal p), SurjVal.v self p = ofN 1
SurjVal.v_uniformizer nav: SurjVal p
nav,R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

n: ℕ

ih: SurjVal.v nav (p ^ n) = ofN n

succofN 1 + ofN n = ofN (Nat.succ n) R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

n: ℕ

ih: SurjVal.v nav (p ^ n) = ofN n

succSurjVal.v nav (p ^ Nat.succ n) = ofN (Nat.succ n)add_ofN: ∀ (a b : ℕ), ofN a + ofN b = ofN (a + b)
add_ofNR: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

n: ℕ

ih: SurjVal.v nav (p ^ n) = ofN n

succofN (1 + n) = ofN (Nat.succ n)]R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

n: ℕ

ih: SurjVal.v nav (p ^ n) = ofN n

succofN (1 + n) = ofN (Nat.succ n)
    R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

n: ℕ

ih: SurjVal.v nav (p ^ n) = ofN n

succSurjVal.v nav (p ^ Nat.succ n) = ofN (Nat.succ n)simp [Nat.succ_eq_add_one: ∀ (n : ℕ), Nat.succ n = n + 1
Nat.succ_eq_add_one, add_comm: ∀ {G : Type ?u.7946} [inst : AddCommSemigroup G] (a b : G), a + b = b + a
add_comm]
Goals accomplished! 🐙

end SurjVal

structure EnatValRing: {R : Type u} →
  {p : R} →
    [inst : IntegralDomain R] →
      (valtn : SurjVal p) →
        (decr_val : R → R) →
          (∀ {x : R}, SurjVal.v valtn x = 0 → decr_val x = x) →
            (∀ {x : R}, SurjVal.v valtn x > 0 → x = p * decr_val x) →
              (residue_char : ℕ) →
                (∀ (n : ℕ), SurjVal.v valtn ↑n > 0 ↔ residue_char ∣ n) → (R → R) → (R → R → R → Bool) → EnatValRing p
EnatValRing {R: Type u
R : Type u: Type (u + 1)
Type u} (p: R
p : R: Type u
R) [IntegralDomain: Type ?u.8171 → Type ?u.8171
IntegralDomain R: Type u
R] where
  valtn: {R : Type u} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn : SurjVal: {R : Type ?u.8176} → R → [inst : IntegralDomain R] → Type ?u.8176
SurjVal p: R
p
  decr_val: {R : Type u} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val : R: Type u
R → R: Type u
R
  zero_valtn_decr: ∀ {R : Type u} {p : R} [inst : IntegralDomain R] (self : EnatValRing p) {x : R},
  SurjVal.v self.valtn x = 0 → EnatValRing.decr_val self x = x
zero_valtn_decr {x: R
x : R: Type u
R} (h: SurjVal.v valtn x = 0
h : valtn: SurjVal p
valtn.v: {R : Type ?u.8191} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x = 0: ?m.8199
0) : decr_val: R → R
decr_val x: R
x = x: R
x
  pos_valtn_decr: ∀ {R : Type u} {p : R} [inst : IntegralDomain R] (self : EnatValRing p) {x : R},
  SurjVal.v self.valtn x > 0 → x = p * EnatValRing.decr_val self x
pos_valtn_decr {x: R
x : R: Type u
R} (h: SurjVal.v valtn x > 0
h : valtn: SurjVal p
valtn.v: {R : Type ?u.8437} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x > 0: ?m.8442
0) : x: R
x = p: R
p * decr_val: R → R
decr_val x: R
x
  residue_char: {R : Type u} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → ℕ
residue_char : ℕ: Type
ℕ
  def_char: ∀ {R : Type u} {p : R} [inst : IntegralDomain R] (self : EnatValRing p) (n : ℕ),
  SurjVal.v self.valtn ↑n > 0 ↔ self.residue_char ∣ n
def_char : ∀ n: ℕ
n : ℕ: Type
ℕ, valtn: SurjVal p
valtn.v: {R : Type ?u.8567} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (n: ℕ
n : R: Type u
R) > 0: ?m.8650
0 ↔ residue_char: ℕ
residue_char ∣ n: ℕ
n
  norm_repr: {R : Type u} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
norm_repr : R: Type u
R → R: Type u
R --generalization of modulo
  quad_roots_in_residue_field: {R : Type u} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R → R → Bool
quad_roots_in_residue_field : R: Type u
R → R: Type u
R → R: Type u
R → Bool: Type
Bool

namespace EnatValRing

/-- reduce the element x by valuation n (by dividing by an appropriate power of the uniformizer) -/
def sub_val: {p : R} → EnatValRing p → R → ℕ → R
sub_val {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.9675} → R → [inst : IntegralDomain R] → Type ?u.9675
EnatValRing p: R
p) (x: R
x : R: Type u
R) (n: ℕ
n : ℕ: Type
ℕ) : R: Type u
R :=
  match n: ℕ
n with
  | 0: ℕ
0 => x: R
x
  | Nat.succ: ℕ → ℕ
Nat.succ n: ℕ
n =>
    match evr: EnatValRing p
evr.valtn: {R : Type ?u.9717} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.9724} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x with
    | 0: ℕ∪∞
0 => x: R
x
    | _ => sub_val: {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr (evr: EnatValRing p
evr.decr_val: {R : Type ?u.9956} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val x: R
x) n: ℕ
n

@[simp]
lemma decr_val_zero: ∀ {R : Type u} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p), decr_val evr 0 = 0
decr_val_zero {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.10425} → R → [inst : IntegralDomain R] → Type ?u.10425
EnatValRing p: R
p) : evr: EnatValRing p
evr.decr_val: {R : Type ?u.10434} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val 0: ?m.10442
0 = 0: ?m.10494
0 := by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

decr_val evr 0 = 0have v_decr_zero: p * decr_val evr 0 = 0
v_decr_zero : p: R
p * evr: EnatValRing p
evr.decr_val: {R : Type ?u.10520} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val 0: ?m.10525
0 = 0: ?m.10528
0 := R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

decr_val evr 0 = 0by
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

p * decr_val evr 0 = 0apply Eq.symm: ∀ {α : Sort ?u.10631} {a b : α}, a = b → b = a
Eq.symmR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

h0 = p * decr_val evr 0
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

p * decr_val evr 0 = 0apply evr: EnatValRing p
evr.pos_valtn_decr: ∀ {R : Type ?u.10643} {p : R} [inst : IntegralDomain R] (self : EnatValRing p) {x : R},
  SurjVal.v self.valtn x > 0 → x = p * decr_val self x
pos_valtn_decrR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

hSurjVal.v evr.valtn 0 > 0
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

p * decr_val evr 0 = 0rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

hSurjVal.v evr.valtn 0 > 0val_zero: ∀ {R : Type ?u.10654} [inst : IntegralDomain R] {p : R} (nav : SurjVal p), SurjVal.v nav 0 = ∞
val_zeroR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

h∞ > 0]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

h∞ > 0
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

p * decr_val evr 0 = 0exact Enat.lt_top: ∀ (n : ℕ), ofN n < ∞
Enat.lt_top 0: ?m.10687
0
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

decr_val evr 0 = 0rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

v_decr_zero: p * decr_val evr 0 = 0

decr_val evr 0 = 0mul_eq_zero_iff_factor_eq_zero: ∀ {R : Type ?u.10701} [inst : IntegralDomain R] (a b : R), a * b = 0 ↔ a = 0 ∨ b = 0
mul_eq_zero_iff_factor_eq_zeroR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

v_decr_zero: p = 0 ∨ decr_val evr 0 = 0

decr_val evr 0 = 0]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

v_decr_zero: p = 0 ∨ decr_val evr 0 = 0

decr_val evr 0 = 0 at v_decr_zero: p * decr_val evr 0 = 0
v_decr_zeroR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

v_decr_zero: p = 0 ∨ decr_val evr 0 = 0

decr_val evr 0 = 0
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

decr_val evr 0 = 0exact Or.resolve_left: ∀ {a b : Prop}, a ∨ b → ¬a → b
Or.resolve_left v_decr_zero: p = 0 ∨ decr_val evr 0 = 0
v_decr_zero (p_non_zero: ∀ {R : Type ?u.10753} [inst : IntegralDomain R] {p : R}, SurjVal p → ¬p = 0
p_non_zero evr: EnatValRing p
evr.valtn: {R : Type ?u.10770} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn)
Goals accomplished! 🐙

@[simp]
lemma decr_val_neg: ∀ {p : R} (evr : EnatValRing p) (x : R), decr_val evr (-x) = -decr_val evr x
decr_val_neg {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.10798} → R → [inst : IntegralDomain R] → Type ?u.10798
EnatValRing p: R
p) (x: R
x : R: Type u
R) : evr: EnatValRing p
evr.decr_val: {R : Type ?u.10809} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val (-x: R
x) = -evr: EnatValRing p
evr.decr_val: {R : Type ?u.10841} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val x: R
x := by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

decr_val evr (-x) = -decr_val evr xcases eq_zero_or_pos: ∀ (n : ℕ∪∞), n = ofN 0 ∨ n > ofN 0
eq_zero_or_pos (evr: EnatValRing p
evr.valtn: {R : Type ?u.10854} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.10858} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x) with
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

x✝: SurjVal.v evr.valtn x = ofN 0 ∨ SurjVal.v evr.valtn x > ofN 0

decr_val evr (-x) = -decr_val evr x| inl: ∀ {a b : Prop}, a → a ∨ b
inl h: ?m.10886
h =>
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN 0

inldecr_val evr (-x) = -decr_val evr xhave hm: SurjVal.v evr.valtn (-x) = ofN 0
hm : evr: EnatValRing p
evr.valtn: {R : Type ?u.10918} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.10922} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (-x: R
x) = ofN: ℕ → ℕ∪∞
ofN 0: ?m.10930
0 := R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN 0

inldecr_val evr (-x) = -decr_val evr xby R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN 0

SurjVal.v evr.valtn (-x) = ofN 0simp [h: SurjVal.v evr.valtn x = ofN 0
h]
Goals accomplished! 🐙
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN 0

inldecr_val evr (-x) = -decr_val evr xrw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN 0

hm: SurjVal.v evr.valtn (-x) = ofN 0

inldecr_val evr (-x) = -decr_val evr xevr: EnatValRing p
evr.zero_valtn_decr: ∀ {R : Type ?u.11138} {p : R} [inst : IntegralDomain R] (self : EnatValRing p) {x : R},
  SurjVal.v self.valtn x = 0 → decr_val self x = x
zero_valtn_decr h: ?m.10886
h,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN 0

hm: SurjVal.v evr.valtn (-x) = ofN 0

inldecr_val evr (-x) = -x R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN 0

hm: SurjVal.v evr.valtn (-x) = ofN 0

inldecr_val evr (-x) = -decr_val evr xevr: EnatValRing p
evr.zero_valtn_decr: ∀ {R : Type ?u.11153} {p : R} [inst : IntegralDomain R] (self : EnatValRing p) {x : R},
  SurjVal.v self.valtn x = 0 → decr_val self x = x
zero_valtn_decr hm: SurjVal.v evr.valtn (-x) = ofN 0
hmR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN 0

hm: SurjVal.v evr.valtn (-x) = ofN 0

inl-x = -x]
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

x✝: SurjVal.v evr.valtn x = ofN 0 ∨ SurjVal.v evr.valtn x > ofN 0

decr_val evr (-x) = -decr_val evr x| inr: ∀ {a b : Prop}, b → a ∨ b
inr h: ?m.10887
h =>
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x > ofN 0

inrdecr_val evr (-x) = -decr_val evr xhave hm: SurjVal.v evr.valtn (-x) > ofN 0
hm : evr: EnatValRing p
evr.valtn: {R : Type ?u.11182} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.11186} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (-x: R
x) > ofN: ℕ → ℕ∪∞
ofN 0: ?m.11194
0 := R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x > ofN 0

inrdecr_val evr (-x) = -decr_val evr xby R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x > ofN 0

SurjVal.v evr.valtn (-x) > ofN 0simp [h: SurjVal.v evr.valtn x > ofN 0
h]
Goals accomplished! 🐙
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x > ofN 0

inrdecr_val evr (-x) = -decr_val evr xapply nzero_mul_left_cancel: ∀ {R : Type ?u.11340} [inst : IntegralDomain R] (a b c : R), a ≠ 0 → a * b = a * c → b = c
nzero_mul_left_cancel p: R
p _: ?m.11341
_ _: ?m.11341
_ (p_non_zero: ∀ {R : Type ?u.11345} [inst : IntegralDomain R] {p : R}, SurjVal p → ¬p = 0
p_non_zero evr: EnatValRing p
evr.valtn: {R : Type ?u.11365} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn)R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x > ofN 0

hm: SurjVal.v evr.valtn (-x) > ofN 0

inrp * decr_val evr (-x) = p * -decr_val evr x
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x > ofN 0

inrdecr_val evr (-x) = -decr_val evr xrw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x > ofN 0

hm: SurjVal.v evr.valtn (-x) > ofN 0

inrp * decr_val evr (-x) = p * -decr_val evr x←neg_mul_right: ∀ {R : Type ?u.11373} [inst : Ring R] (a b : R), -(a * b) = a * -b
neg_mul_right,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x > ofN 0

hm: SurjVal.v evr.valtn (-x) > ofN 0

inrp * decr_val evr (-x) = -(p * decr_val evr x) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x > ofN 0

hm: SurjVal.v evr.valtn (-x) > ofN 0

inrp * decr_val evr (-x) = p * -decr_val evr x←evr: EnatValRing p
evr.pos_valtn_decr: ∀ {R : Type ?u.11416} {p : R} [inst : IntegralDomain R] (self : EnatValRing p) {x : R},
  SurjVal.v self.valtn x > 0 → x = p * decr_val self x
pos_valtn_decr h: ?m.10887
h,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x > ofN 0

hm: SurjVal.v evr.valtn (-x) > ofN 0

inrp * decr_val evr (-x) = -x R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x > ofN 0

hm: SurjVal.v evr.valtn (-x) > ofN 0

inrp * decr_val evr (-x) = p * -decr_val evr x←evr: EnatValRing p
evr.pos_valtn_decr: ∀ {R : Type ?u.11428} {p : R} [inst : IntegralDomain R] (self : EnatValRing p) {x : R},
  SurjVal.v self.valtn x > 0 → x = p * decr_val self x
pos_valtn_decr hm: SurjVal.v evr.valtn (-x) > ofN 0
hmR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x > ofN 0

hm: SurjVal.v evr.valtn (-x) > ofN 0

inr-x = -x]
Goals accomplished! 🐙

@[simp]
lemma decr_val_p_mul: ∀ {p : R} (evr : EnatValRing p) (x : R), decr_val evr (p * x) = x
decr_val_p_mul {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.11481} → R → [inst : IntegralDomain R] → Type ?u.11481
EnatValRing p: R
p) (x: R
x : R: Type u
R) : evr: EnatValRing p
evr.decr_val: {R : Type ?u.11492} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val (p: R
p * x: R
x) = x: R
x := by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

decr_val evr (p * x) = xhave h: p * x = p * decr_val evr (p * x)
h : (p: R
p * x: R
x) = p: R
p * decr_val: {R : Type ?u.11607} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val evr: EnatValRing p
evr (p: R
p * x: R
x) := R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

decr_val evr (p * x) = xby
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

p * x = p * decr_val evr (p * x)apply evr: EnatValRing p
evr.pos_valtn_decr: ∀ {R : Type ?u.11748} {p : R} [inst : IntegralDomain R] (self : EnatValRing p) {x : R},
  SurjVal.v self.valtn x > 0 → x = p * decr_val self x
pos_valtn_decrR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

SurjVal.v evr.valtn (p * x) > 0
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

p * x = p * decr_val evr (p * x)rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

SurjVal.v evr.valtn (p * x) > 0evr: EnatValRing p
evr.valtn: {R : Type ?u.11759} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v_mul_eq_add_v: ∀ {R : Type ?u.11763} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a b : R),
  SurjVal.v self (a * b) = SurjVal.v self a + SurjVal.v self b
v_mul_eq_add_v,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

SurjVal.v evr.valtn p + SurjVal.v evr.valtn x > 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

SurjVal.v evr.valtn (p * x) > 0evr: EnatValRing p
evr.valtn: {R : Type ?u.11788} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v_uniformizer: ∀ {R : Type ?u.11792} {p : R} [inst : IntegralDomain R] (self : SurjVal p), SurjVal.v self p = ofN 1
v_uniformizerR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

ofN 1 + SurjVal.v evr.valtn x > 0]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

ofN 1 + SurjVal.v evr.valtn x > 0
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

p * x = p * decr_val evr (p * x)apply lt_of_lt_of_le: ∀ {α : Type ?u.11809} [inst : Preorder α] {a b c : α}, a < b → b ≤ c → a < c
lt_of_lt_of_le ((Enat.lt_ofN: ∀ (m n : ℕ), m < n ↔ ofN m < ofN n
Enat.lt_ofN 0: ?m.11816
0 1: ?m.11827
1).1: ∀ {a b : Prop}, (a ↔ b) → a → b
1 (Nat.lt_succ_self: ∀ (n : ℕ), n < Nat.succ n
Nat.lt_succ_self 0: ?m.11844
0)) (Enat.le_add_right: ∀ (n k : ℕ∪∞), n ≤ n + k
Enat.le_add_right (ofN: ℕ → ℕ∪∞
ofN 1: ?m.11849
1) _: ℕ∪∞
_)
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

decr_val evr (p * x) = xapply nzero_mul_left_cancel: ∀ {R : Type ?u.11868} [inst : IntegralDomain R] (a b c : R), a ≠ 0 → a * b = a * c → b = c
nzero_mul_left_cancel p: R
p _: ?m.11869
_ _: ?m.11869
_ (p_non_zero: ∀ {R : Type ?u.11873} [inst : IntegralDomain R] {p : R}, SurjVal p → ¬p = 0
p_non_zero evr: EnatValRing p
evr.valtn: {R : Type ?u.11890} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn)R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: p * x = p * decr_val evr (p * x)

p * decr_val evr (p * x) = p * x
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

decr_val evr (p * x) = xexact h: p * x = p * decr_val evr (p * x)
h.symm: ∀ {α : Sort ?u.11898} {a b : α}, a = b → b = a
symm
Goals accomplished! 🐙

@[simp]
lemma sub_val_zero_n: ∀ {p : R} (evr : EnatValRing p) (n : ℕ), sub_val evr 0 n = 0
sub_val_zero_n {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.11932} → R → [inst : IntegralDomain R] → Type ?u.11932
EnatValRing p: R
p) (n: ℕ
n : ℕ: Type
ℕ) : sub_val: {R : Type ?u.11943} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr 0: ?m.11954
0 n: ℕ
n = 0: ?m.12006
0 := by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

n: ℕ

sub_val evr 0 n = 0induction n: ℕ
n with
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

n: ℕ

sub_val evr 0 n = 0| zero: ℕ
zero => R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

zerosub_val evr 0 Nat.zero = 0simp [sub_val: {R : Type ?u.12046} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val]
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

n: ℕ

sub_val evr 0 n = 0| succ: ℕ → ℕ
succ n: ℕ
n ih: ?m.12040 n
ih => R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

n: ℕ

ih: sub_val evr 0 n = 0

succsub_val evr 0 (Nat.succ n) = 0simpa [sub_val: {R : Type ?u.12436} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val, decr_val_zero: ∀ {R : Type ?u.12466} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p), decr_val evr 0 = 0
decr_val_zero]
Goals accomplished! 🐙

@[simp]
lemma sub_val_x_zero: ∀ {p : R} (evr : EnatValRing p) (x : R), sub_val evr x 0 = x
sub_val_x_zero {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.13412} → R → [inst : IntegralDomain R] → Type ?u.13412
EnatValRing p: R
p) (x: R
x : R: Type u
R) : sub_val: {R : Type ?u.13423} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x 0: ?m.13434
0 = x: R
x := by R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

sub_val evr x 0 = xrfl
Goals accomplished! 🐙

lemma sub_val_val_zero: ∀ {p : R} (evr : EnatValRing p) (x : R) (m : ℕ), SurjVal.v evr.valtn x = 0 → sub_val evr x m = x
sub_val_val_zero {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.13493} → R → [inst : IntegralDomain R] → Type ?u.13493
EnatValRing p: R
p) (x: R
x : R: Type u
R) (m: ℕ
m : ℕ: Type
ℕ) (h: SurjVal.v evr.valtn x = 0
h : evr: EnatValRing p
evr.valtn: {R : Type ?u.13506} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.13513} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x = 0: ?m.13521
0) :
  sub_val: {R : Type ?u.13753} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x m: ℕ
m = x: R
x := by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = 0

sub_val evr x m = xcases m: ℕ
m with
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = 0

sub_val evr x m = x| zero: ℕ
zero => R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = 0

zerosub_val evr x Nat.zero = xexact sub_val_x_zero: ∀ {R : Type ?u.13804} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R), sub_val evr x 0 = x
sub_val_x_zero evr: EnatValRing p
evr x: R
x
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = 0

sub_val evr x m = x| succ: ℕ → ℕ
succ m: ℕ
m => R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = 0

m: ℕ

succsub_val evr x (Nat.succ m) = xsimp [sub_val: {R : Type ?u.13835} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val, h: SurjVal.v evr.valtn x = 0
h]
Goals accomplished! 🐙

lemma sub_val_val_pos_succ: ∀ {R : Type u} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x ≠ 0 → sub_val evr x (Nat.succ m) = sub_val evr (decr_val evr x) m
sub_val_val_pos_succ {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.14381} → R → [inst : IntegralDomain R] → Type ?u.14381
EnatValRing p: R
p) (x: R
x : R: Type u
R) (m: ℕ
m : ℕ: Type
ℕ) (h: SurjVal.v evr.valtn x ≠ 0
h : evr: EnatValRing p
evr.valtn: {R : Type ?u.14395} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.14402} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x ≠ 0: ?m.14410
0) :
  sub_val: {R : Type ?u.14628} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x (Nat.succ: ℕ → ℕ
Nat.succ m: ℕ
m) = sub_val: {R : Type ?u.14635} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr (evr: EnatValRing p
evr.decr_val: {R : Type ?u.14642} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val x: R
x) m: ℕ
m := by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x ≠ 0

sub_val evr x (Nat.succ m) = sub_val evr (decr_val evr x) msimp [sub_val: {R : Type ?u.14655} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val, h: SurjVal.v evr.valtn x ≠ 0
h]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x ≠ 0

(match SurjVal.v evr.valtn x with
  | ofN Nat.zero => x
  | x_1 => sub_val evr (decr_val evr x) m) =   sub_val evr (decr_val evr x) m
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x ≠ 0

sub_val evr x (Nat.succ m) = sub_val evr (decr_val evr x) mrw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x ≠ 0

(match SurjVal.v evr.valtn x with
  | ofN Nat.zero => x
  | x_1 => sub_val evr (decr_val evr x) m) =   sub_val evr (decr_val evr x) mmatch_non_zero: ∀ {β : Sort ?u.16245} (x : ℕ∪∞) {c1 c2 : β},
  x ≠ 0 →
    (match x with
      | ofN Nat.zero => c1
      | x => c2) =       c2
match_non_zero (evr: EnatValRing p
evr.valtn: {R : Type ?u.16247} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.16251} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x) h: SurjVal.v evr.valtn x ≠ 0
hR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x ≠ 0

sub_val evr (decr_val evr x) m = sub_val evr (decr_val evr x) m]
Goals accomplished! 🐙


lemma val_decr_val: ∀ {m : ℕ} {p : R} (evr : EnatValRing p) (x : R),
  SurjVal.v evr.valtn x = ofN m → SurjVal.v evr.valtn (decr_val evr x) = ofN (m - 1)
val_decr_val {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.16342} → R → [inst : IntegralDomain R] → Type ?u.16342
EnatValRing p: R
p) (x: R
x : R: Type u
R) (h: SurjVal.v evr.valtn x = ofN m
h : evr: EnatValRing p
evr.valtn: {R : Type ?u.16350} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.16354} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x = ofN: ℕ → ℕ∪∞
ofN m: ?m.16337
m) :
  evr: EnatValRing p
evr.valtn: {R : Type ?u.16362} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.16366} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (evr: EnatValRing p
evr.decr_val: {R : Type ?u.16370} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val x: R
x) = ofN: ℕ → ℕ∪∞
ofN (m: ?m.16337
m - 1: ?m.16378
1) := by
  R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN m

SurjVal.v evr.valtn (decr_val evr x) = ofN (m - 1)cases m: ℕ
m with
  R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN m

SurjVal.v evr.valtn (decr_val evr x) = ofN (m - 1)| zero: ℕ
zero => R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN Nat.zero

zeroSurjVal.v evr.valtn (decr_val evr x) = ofN (Nat.zero - 1)rwa [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN Nat.zero

zeroSurjVal.v evr.valtn (decr_val evr x) = ofN (Nat.zero - 1)evr: EnatValRing p
evr.zero_valtn_decr: ∀ {R : Type ?u.16486} {p : R} [inst : IntegralDomain R] (self : EnatValRing p) {x : R},
  SurjVal.v self.valtn x = 0 → decr_val self x = x
zero_valtn_decr h: SurjVal.v evr.valtn x = ofN Nat.zero
hR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN Nat.zero

zeroSurjVal.v evr.valtn x = ofN (Nat.zero - 1)]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN Nat.zero

zeroSurjVal.v evr.valtn x = ofN (Nat.zero - 1)
  R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN m

SurjVal.v evr.valtn (decr_val evr x) = ofN (m - 1)| succ: ℕ → ℕ
succ m: ℕ
m =>
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

succSurjVal.v evr.valtn (decr_val evr x) = ofN (Nat.succ m - 1)have x_pos_val: SurjVal.v evr.valtn x > ofN 0
x_pos_val : evr: EnatValRing p
evr.valtn: {R : Type ?u.16527} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.16531} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x > ofN: ℕ → ℕ∪∞
ofN 0: ?m.16536
0 := R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

succSurjVal.v evr.valtn (decr_val evr x) = ofN (Nat.succ m - 1)by
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

SurjVal.v evr.valtn x > ofN 0rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

SurjVal.v evr.valtn x > ofN 0h: SurjVal.v evr.valtn x = ofN (Nat.succ m)
hR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ofN (Nat.succ m) > ofN 0]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ofN (Nat.succ m) > ofN 0
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

SurjVal.v evr.valtn x > ofN 0exact succ_pos: ∀ (n : ℕ∪∞), ofN 0 < succ n
succ_pos (ofN: ℕ → ℕ∪∞
ofN m: ℕ
m)
Goals accomplished! 🐙
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

succSurjVal.v evr.valtn (decr_val evr x) = ofN (Nat.succ m - 1)apply add_right_cancel_ofN: ∀ (a : ℕ) (b c : ℕ∪∞), b + ofN a = c + ofN a → b = c
add_right_cancel_ofN 1: ?m.16575
1R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

x_pos_val: SurjVal.v evr.valtn x > ofN 0

succ.aSurjVal.v evr.valtn (decr_val evr x) + ofN 1 = ofN (Nat.succ m - 1) + ofN 1
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

succSurjVal.v evr.valtn (decr_val evr x) = ofN (Nat.succ m - 1)rwa [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

x_pos_val: SurjVal.v evr.valtn x > ofN 0

succ.aSurjVal.v evr.valtn (decr_val evr x) + ofN 1 = ofN (Nat.succ m - 1) + ofN 1add_ofN: ∀ (a b : ℕ), ofN a + ofN b = ofN (a + b)
add_ofN,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

x_pos_val: SurjVal.v evr.valtn x > ofN 0

succ.aSurjVal.v evr.valtn (decr_val evr x) + ofN 1 = ofN (Nat.succ m - 1 + 1) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

x_pos_val: SurjVal.v evr.valtn x > ofN 0

succ.aSurjVal.v evr.valtn (decr_val evr x) + ofN 1 = ofN (Nat.succ m - 1) + ofN 1←evr: EnatValRing p
evr.valtn: {R : Type ?u.16606} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v_uniformizer: ∀ {R : Type ?u.16610} {p : R} [inst : IntegralDomain R] (self : SurjVal p), SurjVal.v self p = ofN 1
v_uniformizer,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

x_pos_val: SurjVal.v evr.valtn x > ofN 0

succ.aSurjVal.v evr.valtn (decr_val evr x) + SurjVal.v evr.valtn p = ofN (Nat.succ m - 1 + 1) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

x_pos_val: SurjVal.v evr.valtn x > ofN 0

succ.aSurjVal.v evr.valtn (decr_val evr x) + ofN 1 = ofN (Nat.succ m - 1) + ofN 1←evr: EnatValRing p
evr.valtn: {R : Type ?u.16623} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v_mul_eq_add_v: ∀ {R : Type ?u.16627} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a b : R),
  SurjVal.v self (a * b) = SurjVal.v self a + SurjVal.v self b
v_mul_eq_add_v,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

x_pos_val: SurjVal.v evr.valtn x > ofN 0

succ.aSurjVal.v evr.valtn (decr_val evr x * p) = ofN (Nat.succ m - 1 + 1) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

x_pos_val: SurjVal.v evr.valtn x > ofN 0

succ.aSurjVal.v evr.valtn (decr_val evr x) + ofN 1 = ofN (Nat.succ m - 1) + ofN 1mul_comm: ∀ {G : Type ?u.16665} [inst : CommSemigroup G] (a b : G), a * b = b * a
mul_comm,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

x_pos_val: SurjVal.v evr.valtn x > ofN 0

succ.aSurjVal.v evr.valtn (p * decr_val evr x) = ofN (Nat.succ m - 1 + 1)
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

x_pos_val: SurjVal.v evr.valtn x > ofN 0

succ.aSurjVal.v evr.valtn (decr_val evr x) + ofN 1 = ofN (Nat.succ m - 1) + ofN 1←evr: EnatValRing p
evr.pos_valtn_decr: ∀ {R : Type ?u.16732} {p : R} [inst : IntegralDomain R] (self : EnatValRing p) {x : R},
  SurjVal.v self.valtn x > 0 → x = p * decr_val self x
pos_valtn_decr x_pos_val: SurjVal.v evr.valtn x > ofN 0
x_pos_val,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

x_pos_val: SurjVal.v evr.valtn x > ofN 0

succ.aSurjVal.v evr.valtn x = ofN (Nat.succ m - 1 + 1) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

x_pos_val: SurjVal.v evr.valtn x > ofN 0

succ.aSurjVal.v evr.valtn (decr_val evr x) + ofN 1 = ofN (Nat.succ m - 1) + ofN 1Nat.succ_sub_one: ∀ (n : ℕ), Nat.succ n - 1 = n
Nat.succ_sub_oneR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

x_pos_val: SurjVal.v evr.valtn x > ofN 0

succ.aSurjVal.v evr.valtn x = ofN (m + 1)]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

x_pos_val: SurjVal.v evr.valtn x > ofN 0

succ.aSurjVal.v evr.valtn x = ofN (m + 1)

lemma sub_val_decr_val_comm: ∀ {p : R} (evr : EnatValRing p) (x : R) (n : ℕ), sub_val evr (decr_val evr x) n = decr_val evr (sub_val evr x n)
sub_val_decr_val_comm {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.16792} → R → [inst : IntegralDomain R] → Type ?u.16792
EnatValRing p: R
p) (x: R
x : R: Type u
R) (n: ℕ
n : ℕ: Type
ℕ) : sub_val: {R : Type ?u.16805} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr (evr: EnatValRing p
evr.decr_val: {R : Type ?u.16815} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val x: R
x) n: ℕ
n = evr: EnatValRing p
evr.decr_val: {R : Type ?u.16819} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val (sub_val: {R : Type ?u.16823} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x n: ℕ
n) := by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

sub_val evr (decr_val evr x) n = decr_val evr (sub_val evr x n)have general: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)
general : ∀ a: ?m.16837
a, sub_val: {R : Type ?u.16841} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr (evr: EnatValRing p
evr.decr_val: {R : Type ?u.16848} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val a: ?m.16837
a) n: ℕ
n = evr: EnatValRing p
evr.decr_val: {R : Type ?u.16852} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val (sub_val: {R : Type ?u.16856} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr a: ?m.16837
a n: ℕ
n) := R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

sub_val evr (decr_val evr x) n = decr_val evr (sub_val evr x n)by
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)induction n: ℕ
n with
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)| zero: ℕ
zero =>
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

zero∀ (a : R), sub_val evr (decr_val evr a) Nat.zero = decr_val evr (sub_val evr a Nat.zero)simp [sub_val_x_zero: ∀ {R : Type ?u.16884} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R), sub_val evr x 0 = x
sub_val_x_zero]
Goals accomplished! 🐙
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)| succ: ℕ → ℕ
succ n: ℕ
n ih: ?m.16877 n
ih =>
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

succ∀ (a : R), sub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))intro a: R
aR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

succsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

succ∀ (a : R), sub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))cases Enat.eq_zero_or_pos: ∀ (n : ℕ∪∞), n = ofN 0 ∨ n > ofN 0
Enat.eq_zero_or_pos (evr: EnatValRing p
evr.valtn: {R : Type ?u.17331} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.17335} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v a: R
a) with
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

x✝: SurjVal.v evr.valtn a = ofN 0 ∨ SurjVal.v evr.valtn a > ofN 0

succsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))| inl: ∀ {a b : Prop}, a → a ∨ b
inl h: ?m.17363
h =>
        R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a = ofN 0

succ.inlsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a = ofN 0

succ.inlsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))evr: EnatValRing p
evr.zero_valtn_decr: ∀ {R : Type ?u.17393} {p : R} [inst : IntegralDomain R] (self : EnatValRing p) {x : R},
  SurjVal.v self.valtn x = 0 → decr_val self x = x
zero_valtn_decr h: ?m.17363
h,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a = ofN 0

succ.inlsub_val evr a (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n)) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a = ofN 0

succ.inlsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))sub_val_val_zero: ∀ {R : Type ?u.17408} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x = 0 → sub_val evr x m = x
sub_val_val_zero evr: EnatValRing p
evr a: R
a n: ℕ
n.succ: ℕ → ℕ
succ h: ?m.17363
h,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a = ofN 0

succ.inla = decr_val evr a R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a = ofN 0

succ.inlsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))evr: EnatValRing p
evr.zero_valtn_decr: ∀ {R : Type ?u.17419} {p : R} [inst : IntegralDomain R] (self : EnatValRing p) {x : R},
  SurjVal.v self.valtn x = 0 → decr_val self x = x
zero_valtn_decr h: ?m.17363
hR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a = ofN 0

succ.inla = a]
Goals accomplished! 🐙
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

x✝: SurjVal.v evr.valtn a = ofN 0 ∨ SurjVal.v evr.valtn a > ofN 0

succsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))| inr: ∀ {a b : Prop}, b → a ∨ b
inr h: ?m.17364
h =>
        R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

succ.inrsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))cases Enat.eq_zero_or_pos: ∀ (n : ℕ∪∞), n = ofN 0 ∨ n > ofN 0
Enat.eq_zero_or_pos (evr: EnatValRing p
evr.valtn: {R : Type ?u.17446} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.17450} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (evr: EnatValRing p
evr.decr_val: {R : Type ?u.17454} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val a: R
a)) with
        R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

x✝: SurjVal.v evr.valtn (decr_val evr a) = ofN 0 ∨ SurjVal.v evr.valtn (decr_val evr a) > ofN 0

succ.inrsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))| inl: ∀ {a b : Prop}, a → a ∨ b
inl h': ?m.17477
h' =>
          R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) = ofN 0

succ.inr.inlsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) = ofN 0

succ.inr.inlsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))sub_val_val_zero: ∀ {R : Type ?u.17507} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x = 0 → sub_val evr x m = x
sub_val_val_zero evr: EnatValRing p
evr (evr: EnatValRing p
evr.decr_val: {R : Type ?u.17514} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val a: R
a) n: ℕ
n.succ: ℕ → ℕ
succ h': ?m.17477
h',R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) = ofN 0

succ.inr.inldecr_val evr a = decr_val evr (sub_val evr a (Nat.succ n)) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) = ofN 0

succ.inr.inlsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))sub_val_val_pos_succ: ∀ {R : Type ?u.17522} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x ≠ 0 → sub_val evr x (Nat.succ m) = sub_val evr (decr_val evr x) m
sub_val_val_pos_succ evr: EnatValRing p
evr a: R
a n: ℕ
n (ne_of_gt: ∀ {α : Type ?u.17529} [inst : Preorder α] {a b : α}, b < a → a ≠ b
ne_of_gt h: ?m.17364
h),R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) = ofN 0

succ.inr.inldecr_val evr a = decr_val evr (sub_val evr (decr_val evr a) n) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) = ofN 0

succ.inr.inlsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))←ih: ?m.16877 n
ih (evr: EnatValRing p
evr.decr_val: {R : Type ?u.17550} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val a: R
a),R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) = ofN 0

succ.inr.inldecr_val evr a = sub_val evr (decr_val evr (decr_val evr a)) n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) = ofN 0

succ.inr.inlsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))evr: EnatValRing p
evr.zero_valtn_decr: ∀ {R : Type ?u.17557} {p : R} [inst : IntegralDomain R] (self : EnatValRing p) {x : R},
  SurjVal.v self.valtn x = 0 → decr_val self x = x
zero_valtn_decr h': ?m.17477
h',R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) = ofN 0

succ.inr.inldecr_val evr a = sub_val evr (decr_val evr a) n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) = ofN 0

succ.inr.inlsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))sub_val_val_zero: ∀ {R : Type ?u.17565} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x = 0 → sub_val evr x m = x
sub_val_val_zero evr: EnatValRing p
evr (evr: EnatValRing p
evr.decr_val: {R : Type ?u.17572} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val a: R
a) n: ℕ
n h': ?m.17477
h'R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) = ofN 0

succ.inr.inldecr_val evr a = decr_val evr a]
Goals accomplished! 🐙
        R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

x✝: SurjVal.v evr.valtn (decr_val evr a) = ofN 0 ∨ SurjVal.v evr.valtn (decr_val evr a) > ofN 0

succ.inrsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))| inr: ∀ {a b : Prop}, b → a ∨ b
inr h': ?m.17478
h' =>
          R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) > ofN 0

succ.inr.inrsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) > ofN 0

succ.inr.inrsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))sub_val_val_pos_succ: ∀ {R : Type ?u.17598} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x ≠ 0 → sub_val evr x (Nat.succ m) = sub_val evr (decr_val evr x) m
sub_val_val_pos_succ evr: EnatValRing p
evr (evr: EnatValRing p
evr.decr_val: {R : Type ?u.17605} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val a: R
a) n: ℕ
n (ne_of_gt: ∀ {α : Type ?u.17609} [inst : Preorder α] {a b : α}, b < a → a ≠ b
ne_of_gt h': ?m.17478
h'),R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) > ofN 0

succ.inr.inrsub_val evr (decr_val evr (decr_val evr a)) n = decr_val evr (sub_val evr a (Nat.succ n)) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) > ofN 0

succ.inr.inrsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))ih: ?m.16877 n
ih (evr: EnatValRing p
evr.decr_val: {R : Type ?u.17618} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val a: R
a),R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) > ofN 0

succ.inr.inrdecr_val evr (sub_val evr (decr_val evr a) n) = decr_val evr (sub_val evr a (Nat.succ n)) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) > ofN 0

succ.inr.inrsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))sub_val_val_pos_succ: ∀ {R : Type ?u.17625} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x ≠ 0 → sub_val evr x (Nat.succ m) = sub_val evr (decr_val evr x) m
sub_val_val_pos_succ evr: EnatValRing p
evr a: R
a n: ℕ
n (ne_of_gt: ∀ {α : Type ?u.17632} [inst : Preorder α] {a b : α}, b < a → a ≠ b
ne_of_gt h: ?m.17364
h)R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) > ofN 0

succ.inr.inrdecr_val evr (sub_val evr (decr_val evr a) n) = decr_val evr (sub_val evr (decr_val evr a) n)]
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

sub_val evr (decr_val evr x) n = decr_val evr (sub_val evr x n)exact general: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)
general x: R
x
Goals accomplished! 🐙

lemma val_sub_val_eq: ∀ {R : Type u} [inst : IntegralDomain R] {m : ℕ} {p : R} (evr : EnatValRing p) (x : R) (n : ℕ),
  SurjVal.v evr.valtn x = ofN m → SurjVal.v evr.valtn (sub_val evr x n) = ofN (m - n)
val_sub_val_eq {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.17734} → R → [inst : IntegralDomain R] → Type ?u.17734
EnatValRing p: R
p) (x: R
x : R: Type u
R) (n: ℕ
n : ℕ: Type
ℕ) (h: SurjVal.v evr.valtn x = ofN m
h : evr: EnatValRing p
evr.valtn: {R : Type ?u.17744} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.17748} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x = ofN: ℕ → ℕ∪∞
ofN m: ?m.17729
m) :
  evr: EnatValRing p
evr.valtn: {R : Type ?u.17756} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.17760} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (sub_val: {R : Type ?u.17764} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x n: ℕ
n) = ofN: ℕ → ℕ∪∞
ofN (m: ?m.17729
m - n: ℕ
n) := by
  R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x = ofN m

SurjVal.v evr.valtn (sub_val evr x n) = ofN (m - n)induction n: ℕ
n with
  R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x = ofN m

SurjVal.v evr.valtn (sub_val evr x n) = ofN (m - n)| zero: ℕ
zero => R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN m

zeroSurjVal.v evr.valtn (sub_val evr x Nat.zero) = ofN (m - Nat.zero)rwa [R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN m

zeroSurjVal.v evr.valtn (sub_val evr x Nat.zero) = ofN (m - Nat.zero)sub_val_x_zero: ∀ {R : Type ?u.17836} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R), sub_val evr x 0 = x
sub_val_x_zero,R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN m

zeroSurjVal.v evr.valtn x = ofN (m - Nat.zero) R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN m

zeroSurjVal.v evr.valtn (sub_val evr x Nat.zero) = ofN (m - Nat.zero)Nat.sub_zero: ∀ (n : ℕ), n - 0 = n
Nat.sub_zeroR: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN m

zeroSurjVal.v evr.valtn x = ofN m]R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN m

zeroSurjVal.v evr.valtn x = ofN m
  R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x = ofN m

SurjVal.v evr.valtn (sub_val evr x n) = ofN (m - n)| succ: ℕ → ℕ
succ n: ℕ
n ih: ?m.17830 n
ih =>
    R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN m

n: ℕ

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (m - n)

succSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (m - Nat.succ n)cases m: ℕ
m with
    R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN m

n: ℕ

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (m - n)

succSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (m - Nat.succ n)| zero: ℕ
zero =>
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x = ofN Nat.zero

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.zero - n)

succ.zeroSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.zero - Nat.succ n)rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x = ofN Nat.zero

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.zero - n)

succ.zeroSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.zero - Nat.succ n)Nat.zero_sub: ∀ (n : ℕ), 0 - n = 0
Nat.zero_subR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x = ofN Nat.zero

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN 0

succ.zeroSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.zero - Nat.succ n)]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x = ofN Nat.zero

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN 0

succ.zeroSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.zero - Nat.succ n) at ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.zero - n)
ihR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x = ofN Nat.zero

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN 0

succ.zeroSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.zero - Nat.succ n)
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x = ofN Nat.zero

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.zero - n)

succ.zeroSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.zero - Nat.succ n)rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x = ofN Nat.zero

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN 0

succ.zeroSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.zero - Nat.succ n)Nat.zero_sub: ∀ (n : ℕ), 0 - n = 0
Nat.zero_sub,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x = ofN Nat.zero

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN 0

succ.zeroSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x = ofN Nat.zero

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN 0

succ.zeroSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.zero - Nat.succ n)sub_val_val_zero: ∀ {R : Type ?u.17943} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x = 0 → sub_val evr x m = x
sub_val_val_zero evr: EnatValRing p
evr x: R
x n: ℕ
n.succ: ℕ → ℕ
succ h: SurjVal.v evr.valtn x = ofN Nat.zero
hR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x = ofN Nat.zero

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN 0

succ.zeroSurjVal.v evr.valtn x = ofN 0]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x = ofN Nat.zero

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN 0

succ.zeroSurjVal.v evr.valtn x = ofN 0
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x = ofN Nat.zero

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.zero - n)

succ.zeroSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.zero - Nat.succ n)exact h: SurjVal.v evr.valtn x = ofN Nat.zero
h
Goals accomplished! 🐙
    R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN m

n: ℕ

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (m - n)

succSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (m - Nat.succ n)| succ: ℕ → ℕ
succ m: ℕ
m =>
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.succ m - Nat.succ n)rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.succ m - Nat.succ n)sub_val_val_pos_succ: ∀ {R : Type ?u.17981} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x ≠ 0 → sub_val evr x (Nat.succ m) = sub_val evr (decr_val evr x) m
sub_val_val_pos_succ,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succSurjVal.v evr.valtn (sub_val evr (decr_val evr x) n) = ofN (Nat.succ m - Nat.succ n)
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succ.hSurjVal.v evr.valtn x ≠ 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.succ m - Nat.succ n)sub_val_decr_val_comm: ∀ {R : Type ?u.17999} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (n : ℕ),
  sub_val evr (decr_val evr x) n = decr_val evr (sub_val evr x n)
sub_val_decr_val_comm,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succSurjVal.v evr.valtn (decr_val evr (sub_val evr x n)) = ofN (Nat.succ m - Nat.succ n)
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succ.hSurjVal.v evr.valtn x ≠ 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.succ m - Nat.succ n)val_decr_val: ∀ {R : Type ?u.18020} [inst : IntegralDomain R] {m : ℕ} {p : R} (evr : EnatValRing p) (x : R),
  SurjVal.v evr.valtn x = ofN m → SurjVal.v evr.valtn (decr_val evr x) = ofN (m - 1)
val_decr_val evr: EnatValRing p
evr (sub_val: {R : Type ?u.18028} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x n: ℕ
n) ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)
ih,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succofN (Nat.succ m - n - 1) = ofN (Nat.succ m - Nat.succ n)
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succ.hSurjVal.v evr.valtn x ≠ 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.succ m - Nat.succ n)←eq_ofN: ∀ (m n : ℕ), m = n ↔ ofN m = ofN n
eq_ofN,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succNat.succ m - n - 1 = Nat.succ m - Nat.succ n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succ.hSurjVal.v evr.valtn x ≠ 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.succ m - Nat.succ n)Nat.succ_eq_add_one: ∀ (n : ℕ), Nat.succ n = n + 1
Nat.succ_eq_add_one n: ℕ
n,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succNat.succ m - n - 1 = Nat.succ m - (n + 1)
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succ.hSurjVal.v evr.valtn x ≠ 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.succ m - Nat.succ n)Nat.sub_sub: ∀ (n m k : ℕ), n - m - k = n - (m + k)
Nat.sub_subR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succNat.succ m - (n + 1) = Nat.succ m - (n + 1)
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succ.hSurjVal.v evr.valtn x ≠ 0]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succ.hSurjVal.v evr.valtn x ≠ 0
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.succ m - Nat.succ n)rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succ.hSurjVal.v evr.valtn x ≠ 0h: SurjVal.v evr.valtn x = ofN (Nat.succ m)
h,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succ.hofN (Nat.succ m) ≠ 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succ.hSurjVal.v evr.valtn x ≠ 0(show 0: ?m.18068
0 = ofN: ℕ → ℕ∪∞
ofN 0: ?m.18084
0 by R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succ.hofN (Nat.succ m) ≠ 0rfl
Goals accomplished! 🐙)R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succ.hofN (Nat.succ m) ≠ ofN 0]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succ.hofN (Nat.succ m) ≠ ofN 0
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.succ m - Nat.succ n)simp [←eq_ofN: ∀ (m n : ℕ), m = n ↔ ofN m = ofN n
eq_ofN]
Goals accomplished! 🐙

lemma val_sub_val_le: ∀ {R : Type u} [inst : IntegralDomain R] {m : ℕ} {p : R} (evr : EnatValRing p) (x : R) (n : ℕ),
  SurjVal.v evr.valtn x ≥ ofN m → SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)
val_sub_val_le {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.18472} → R → [inst : IntegralDomain R] → Type ?u.18472
EnatValRing p: R
p) (x: R
x : R: Type u
R) (n: ℕ
n : ℕ: Type
ℕ) (h: SurjVal.v evr.valtn x ≥ ofN m
h : evr: EnatValRing p
evr.valtn: {R : Type ?u.18482} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.18486} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x ≥ ofN: ℕ → ℕ∪∞
ofN m: ?m.18467
m) : evr: EnatValRing p
evr.valtn: {R : Type ?u.18498} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.18502} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (sub_val: {R : Type ?u.18506} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x n: ℕ
n) ≥ ofN: ℕ → ℕ∪∞
ofN (m: ?m.18467
m - n: ℕ
n) := by
  R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)cases enat_disjunction: ∀ (a : ℕ∪∞), a = ∞ ∨ ∃ n, a = ofN n
enat_disjunction (evr: EnatValRing p
evr.valtn: {R : Type ?u.18567} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.18571} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x) with
  R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

x✝: SurjVal.v evr.valtn x = ∞ ∨ ∃ n, SurjVal.v evr.valtn x = ofN n

SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)| inl: ∀ {a b : Prop}, a → a ∨ b
inl h': ?m.18598
h' =>
    R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': SurjVal.v evr.valtn x = ∞

inlSurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)have topcase: x = 0
topcase : x: R
x = 0: ?m.18631
0 := (evr: EnatValRing p
evr.valtn: {R : Type ?u.18695} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v_eq_top_iff_zero: ∀ {R : Type ?u.18699} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a : R), SurjVal.v self a = ∞ ↔ a = 0
v_eq_top_iff_zero x: R
x).1: ∀ {a b : Prop}, (a ↔ b) → a → b
1 h': ?m.18598
h'R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': SurjVal.v evr.valtn x = ∞

topcase: x = 0

inlSurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)
    R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': SurjVal.v evr.valtn x = ∞

inlSurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)rw [R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': SurjVal.v evr.valtn x = ∞

topcase: x = 0

inlSurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)topcase: x = 0
topcase,R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': SurjVal.v evr.valtn x = ∞

topcase: x = 0

inlSurjVal.v evr.valtn (sub_val evr 0 n) ≥ ofN (m - n) R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': SurjVal.v evr.valtn x = ∞

topcase: x = 0

inlSurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)sub_val_zero_n: ∀ {R : Type ?u.18717} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (n : ℕ), sub_val evr 0 n = 0
sub_val_zero_n,R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': SurjVal.v evr.valtn x = ∞

topcase: x = 0

inlSurjVal.v evr.valtn 0 ≥ ofN (m - n) R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': SurjVal.v evr.valtn x = ∞

topcase: x = 0

inlSurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)(evr: EnatValRing p
evr.valtn: {R : Type ?u.18740} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v_eq_top_iff_zero: ∀ {R : Type ?u.18744} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a : R), SurjVal.v self a = ∞ ↔ a = 0
v_eq_top_iff_zero 0: ?m.18749
0).2: ∀ {a b : Prop}, (a ↔ b) → b → a
2 rfl: ∀ {α : Sort ?u.18753} {a : α}, a = a
rflR: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': SurjVal.v evr.valtn x = ∞

topcase: x = 0

inl∞ ≥ ofN (m - n)]R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': SurjVal.v evr.valtn x = ∞

topcase: x = 0

inl∞ ≥ ofN (m - n)
    R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': SurjVal.v evr.valtn x = ∞

inlSurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)exact le.below_top: ∀ {n : ℕ∪∞}, Enat.le n ∞
le.below_top
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

x✝: SurjVal.v evr.valtn x = ∞ ∨ ∃ n, SurjVal.v evr.valtn x = ofN n

SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)| inr: ∀ {a b : Prop}, b → a ∨ b
inr h': ?m.18599
h' =>
    R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': ∃ n, SurjVal.v evr.valtn x = ofN n

inrSurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)have H: ∀ (a : ℕ), SurjVal.v evr.valtn x = ofN a → SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)
H : ∀ (a: ℕ
a : ℕ: Type
ℕ), evr: EnatValRing p
evr.valtn: {R : Type ?u.18787} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.18791} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x = ofN: ℕ → ℕ∪∞
ofN a: ℕ
a → evr: EnatValRing p
evr.valtn: {R : Type ?u.18798} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.18802} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (sub_val: {R : Type ?u.18806} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x n: ℕ
n) ≥ ofN: ℕ → ℕ∪∞
ofN (m: ℕ
m - n: ℕ
n) := R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': ∃ n, SurjVal.v evr.valtn x = ofN n

inrSurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)by
      R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': ∃ n, SurjVal.v evr.valtn x = ofN n

∀ (a : ℕ), SurjVal.v evr.valtn x = ofN a → SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)intro a: ℕ
a ha: SurjVal.v evr.valtn x = ofN a
haR: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': ∃ n, SurjVal.v evr.valtn x = ofN n

a: ℕ

ha: SurjVal.v evr.valtn x = ofN a

SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)
      R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': ∃ n, SurjVal.v evr.valtn x = ofN n

∀ (a : ℕ), SurjVal.v evr.valtn x = ofN a → SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)have h'': ?m.18849
h'' := val_sub_val_eq: ∀ {R : Type ?u.18850} [inst : IntegralDomain R] {m : ℕ} {p : R} (evr : EnatValRing p) (x : R) (n : ℕ),
  SurjVal.v evr.valtn x = ofN m → SurjVal.v evr.valtn (sub_val evr x n) = ofN (m - n)
val_sub_val_eq evr: EnatValRing p
evr x: R
x n: ℕ
n ha: SurjVal.v evr.valtn x = ofN a
haR: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': ∃ n, SurjVal.v evr.valtn x = ofN n

a: ℕ

ha: SurjVal.v evr.valtn x = ofN a

h'': SurjVal.v evr.valtn (sub_val evr x n) = ofN (a - n)

SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)
      R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': ∃ n, SurjVal.v evr.valtn x = ofN n

∀ (a : ℕ), SurjVal.v evr.valtn x = ofN a → SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)rw [R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': ∃ n, SurjVal.v evr.valtn x = ofN n

a: ℕ

ha: SurjVal.v evr.valtn x = ofN a

h'': SurjVal.v evr.valtn (sub_val evr x n) = ofN (a - n)

SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)h'': ?m.18849
h''R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': ∃ n, SurjVal.v evr.valtn x = ofN n

a: ℕ

ha: SurjVal.v evr.valtn x = ofN a

h'': SurjVal.v evr.valtn (sub_val evr x n) = ofN (a - n)

ofN (a - n) ≥ ofN (m - n)]R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': ∃ n, SurjVal.v evr.valtn x = ofN n

a: ℕ

ha: SurjVal.v evr.valtn x = ofN a

h'': SurjVal.v evr.valtn (sub_val evr x n) = ofN (a - n)

ofN (a - n) ≥ ofN (m - n)
      R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': ∃ n, SurjVal.v evr.valtn x = ofN n

∀ (a : ℕ), SurjVal.v evr.valtn x = ofN a → SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)apply (le_ofN: ∀ (m n : ℕ), m ≤ n ↔ ofN m ≤ ofN n
le_ofN (m: ℕ
m - n: ℕ
n) (a: ℕ
a - n: ℕ
n)).1: ∀ {a b : Prop}, (a ↔ b) → a → b
1R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': ∃ n, SurjVal.v evr.valtn x = ofN n

a: ℕ

ha: SurjVal.v evr.valtn x = ofN a

h'': SurjVal.v evr.valtn (sub_val evr x n) = ofN (a - n)

m - n ≤ a - n
      R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': ∃ n, SurjVal.v evr.valtn x = ofN n

∀ (a : ℕ), SurjVal.v evr.valtn x = ofN a → SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)rw [R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': ∃ n, SurjVal.v evr.valtn x = ofN n

a: ℕ

ha: SurjVal.v evr.valtn x = ofN a

h'': SurjVal.v evr.valtn (sub_val evr x n) = ofN (a - n)

m - n ≤ a - nha: SurjVal.v evr.valtn x = ofN a
haR: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h': ∃ n, SurjVal.v evr.valtn x = ofN n

a: ℕ

h: ofN a ≥ ofN m

ha: SurjVal.v evr.valtn x = ofN a

h'': SurjVal.v evr.valtn (sub_val evr x n) = ofN (a - n)

m - n ≤ a - n]R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h': ∃ n, SurjVal.v evr.valtn x = ofN n

a: ℕ

h: ofN a ≥ ofN m

ha: SurjVal.v evr.valtn x = ofN a

h'': SurjVal.v evr.valtn (sub_val evr x n) = ofN (a - n)

m - n ≤ a - n at h: SurjVal.v evr.valtn x ≥ ofN m
hR: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h': ∃ n, SurjVal.v evr.valtn x = ofN n

a: ℕ

h: ofN a ≥ ofN m

ha: SurjVal.v evr.valtn x = ofN a

h'': SurjVal.v evr.valtn (sub_val evr x n) = ofN (a - n)

m - n ≤ a - n
      R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': ∃ n, SurjVal.v evr.valtn x = ofN n

∀ (a : ℕ), SurjVal.v evr.valtn x = ofN a → SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)apply Nat.sub_le_sub_right: ∀ {n m : ℕ}, n ≤ m → ∀ (k : ℕ), n - k ≤ m - k
Nat.sub_le_sub_right ((le_ofN: ∀ (m n : ℕ), m ≤ n ↔ ofN m ≤ ofN n
le_ofN m: ℕ
m a: ℕ
a).2: ∀ {a b : Prop}, (a ↔ b) → b → a
2 h: ofN a ≥ ofN m
h)
Goals accomplished! 🐙
    R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': ∃ n, SurjVal.v evr.valtn x = ofN n

inrSurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)exact Exists.elim: ∀ {α : Sort ?u.18967} {p : α → Prop} {b : Prop}, (∃ x, p x) → (∀ (a : α), p a → b) → b
Exists.elim h': ?m.18599
h' H: ∀ (a : ℕ), SurjVal.v evr.valtn x = ofN a → SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)
H
Goals accomplished! 🐙

lemma factor_p_of_le_val: ∀ {R : Type u} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x : R} {n : ℕ},
  SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n
factor_p_of_le_val {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.19029} → R → [inst : IntegralDomain R] → Type ?u.19029
EnatValRing p: R
p) {x: R
x : R: Type u
R} {n: ℕ
n : ℕ: Type
ℕ} (h: SurjVal.v evr.valtn x ≥ ofN n
h : evr: EnatValRing p
evr.valtn: {R : Type ?u.19042} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.19049} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x ≥ ofN: ℕ → ℕ∪∞
ofN n: ℕ
n) :
  x: R
x = p: R
p ^ n: ℕ
n * sub_val: {R : Type ?u.19070} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x n: ℕ
n := by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN n

x = p ^ n * sub_val evr x ninduction n: ℕ
n with
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN n

x = p ^ n * sub_val evr x n| zero: ℕ
zero => R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x ≥ ofN Nat.zero

zerox = p ^ Nat.zero * sub_val evr x Nat.zerosimp [sub_val: {R : Type ?u.19315} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val]
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN n

x = p ^ n * sub_val evr x n| succ: ℕ → ℕ
succ n: ℕ
n ih: ?m.19305 n
ih =>
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ Nat.succ n * sub_val evr x (Nat.succ n)rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ Nat.succ n * sub_val evr x (Nat.succ n)sub_val_val_pos_succ: ∀ {R : Type ?u.19575} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x ≠ 0 → sub_val evr x (Nat.succ m) = sub_val evr (decr_val evr x) m
sub_val_val_pos_succ,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ Nat.succ n * sub_val evr (decr_val evr x) n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succ.hSurjVal.v evr.valtn x ≠ 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ Nat.succ n * sub_val evr x (Nat.succ n)sub_val_decr_val_comm: ∀ {R : Type ?u.19593} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (n : ℕ),
  sub_val evr (decr_val evr x) n = decr_val evr (sub_val evr x n)
sub_val_decr_val_comm,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ Nat.succ n * decr_val evr (sub_val evr x n)
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succ.hSurjVal.v evr.valtn x ≠ 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ Nat.succ n * sub_val evr x (Nat.succ n)pow_succ': ∀ {M : Type ?u.19614} [inst : Monoid M] (a : M) (n : ℕ), a ^ (n + 1) = a ^ n * a
pow_succ',R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ n * p * decr_val evr (sub_val evr x n)
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succ.hSurjVal.v evr.valtn x ≠ 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ Nat.succ n * sub_val evr x (Nat.succ n)mul_assoc: ∀ {G : Type ?u.19672} [inst : Semigroup G] (a b c : G), a * b * c = a * (b * c)
mul_assocR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ n * (p * decr_val evr (sub_val evr x n))
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succ.hSurjVal.v evr.valtn x ≠ 0]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ n * (p * decr_val evr (sub_val evr x n))
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succ.hSurjVal.v evr.valtn x ≠ 0
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ Nat.succ n * sub_val evr x (Nat.succ n)have pos_val: SurjVal.v evr.valtn (sub_val evr x n) > 0
pos_val : evr: EnatValRing p
evr.valtn: {R : Type ?u.19776} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.19780} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (sub_val: {R : Type ?u.19784} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x n: ℕ
n) > 0: ?m.19789
0 := R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ n * (p * decr_val evr (sub_val evr x n))
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succ.hSurjVal.v evr.valtn x ≠ 0by
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

SurjVal.v evr.valtn (sub_val evr x n) > 0have h': ?m.20027
h' := val_sub_val_le: ∀ {R : Type ?u.20028} [inst : IntegralDomain R] {m : ℕ} {p : R} (evr : EnatValRing p) (x : R) (n : ℕ),
  SurjVal.v evr.valtn x ≥ ofN m → SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)
val_sub_val_le evr: EnatValRing p
evr x: R
x n: ℕ
n h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)
hR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

h': SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (Nat.succ n - n)

SurjVal.v evr.valtn (sub_val evr x n) > 0
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

SurjVal.v evr.valtn (sub_val evr x n) > 0rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

h': SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (Nat.succ n - n)

SurjVal.v evr.valtn (sub_val evr x n) > 0Nat.succ_eq_add_one: ∀ (n : ℕ), Nat.succ n = n + 1
Nat.succ_eq_add_one,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

h': SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (n + 1 - n)

SurjVal.v evr.valtn (sub_val evr x n) > 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

h': SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (Nat.succ n - n)

SurjVal.v evr.valtn (sub_val evr x n) > 0Nat.add_sub_self_left: ∀ (a b : ℕ), a + b - a = b
Nat.add_sub_self_leftR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

h': SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN 1

SurjVal.v evr.valtn (sub_val evr x n) > 0]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

h': SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN 1

SurjVal.v evr.valtn (sub_val evr x n) > 0 at h': ?m.20027
h'R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

h': SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN 1

SurjVal.v evr.valtn (sub_val evr x n) > 0
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

SurjVal.v evr.valtn (sub_val evr x n) > 0exact lt_of_succ_le: ∀ {n : ℕ} {m : ℕ∪∞}, succ (ofN n) ≤ m → ofN n < m
lt_of_succ_le h': SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN 1
h'
Goals accomplished! 🐙
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ Nat.succ n * sub_val evr x (Nat.succ n)rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

pos_val: SurjVal.v evr.valtn (sub_val evr x n) > 0

succx = p ^ n * (p * decr_val evr (sub_val evr x n))
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succ.hSurjVal.v evr.valtn x ≠ 0←evr: EnatValRing p
evr.pos_valtn_decr: ∀ {R : Type ?u.20112} {p : R} [inst : IntegralDomain R] (self : EnatValRing p) {x : R},
  SurjVal.v self.valtn x > 0 → x = p * decr_val self x
pos_valtn_decr pos_val: SurjVal.v evr.valtn (sub_val evr x n) > 0
pos_valR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

pos_val: SurjVal.v evr.valtn (sub_val evr x n) > 0

succx = p ^ n * sub_val evr x n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succ.hSurjVal.v evr.valtn x ≠ 0]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

pos_val: SurjVal.v evr.valtn (sub_val evr x n) > 0

succx = p ^ n * sub_val evr x n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succ.hSurjVal.v evr.valtn x ≠ 0
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ Nat.succ n * sub_val evr x (Nat.succ n)apply ih: ?m.19305 n
ihR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

pos_val: SurjVal.v evr.valtn (sub_val evr x n) > 0

succSurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succ.hSurjVal.v evr.valtn x ≠ 0
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ Nat.succ n * sub_val evr x (Nat.succ n)exact le_of_succ_le: ∀ {n m : ℕ∪∞}, succ n ≤ m → n ≤ m
le_of_succ_le h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)
hR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succ.hSurjVal.v evr.valtn x ≠ 0
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ Nat.succ n * sub_val evr x (Nat.succ n)apply ne_of_gt: ∀ {α : Type ?u.20150} [inst : Preorder α] {a b : α}, b < a → a ≠ b
ne_of_gtR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succ.h.h0 < SurjVal.v evr.valtn x
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ Nat.succ n * sub_val evr x (Nat.succ n)rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succ.h.h0 < SurjVal.v evr.valtn x←succ_ofN: ∀ (a : ℕ), succ (ofN a) = ofN (Nat.succ a)
succ_ofNR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ succ (ofN n)

succ.h.h0 < SurjVal.v evr.valtn x]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ succ (ofN n)

succ.h.h0 < SurjVal.v evr.valtn x at h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)
hR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ succ (ofN n)

succ.h.h0 < SurjVal.v evr.valtn x
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ Nat.succ n * sub_val evr x (Nat.succ n)exact lt_of_lt_of_le: ∀ {α : Type ?u.20189} [inst : Preorder α] {a b c : α}, a < b → b ≤ c → a < c
lt_of_lt_of_le (succ_pos: ∀ (n : ℕ∪∞), ofN 0 < succ n
succ_pos (ofN: ℕ → ℕ∪∞
ofN n: ℕ
n)) h: SurjVal.v evr.valtn x ≥ succ (ofN n)
h
Goals accomplished! 🐙

lemma factor_p_of_eq_val: ∀ {p : R} (evr : EnatValRing p) {x : R} {n : ℕ}, SurjVal.v evr.valtn x = ofN n → x = p ^ n * sub_val evr x n
factor_p_of_eq_val {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.20229} → R → [inst : IntegralDomain R] → Type ?u.20229
EnatValRing p: R
p) {x: R
x : R: Type u
R} {n: ℕ
n : ℕ: Type
ℕ} (h: SurjVal.v evr.valtn x = ofN n
h : evr: EnatValRing p
evr.valtn: {R : Type ?u.20242} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.20249} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x = ofN: ℕ → ℕ∪∞
ofN n: ℕ
n) :
x: R
x = p: R
p ^ n: ℕ
n * sub_val: {R : Type ?u.20266} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x n: ℕ
n := factor_p_of_le_val: ∀ {R : Type ?u.20486} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x : R} {n : ℕ},
  SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n
factor_p_of_le_val evr: EnatValRing p
evr (le_of_eq: ∀ {α : Type ?u.20516} [inst : Preorder α] {a b : α}, a = b → a ≤ b
le_of_eq (Eq.symm: ∀ {α : Sort ?u.20527} {a b : α}, a = b → b = a
Eq.symm h: SurjVal.v evr.valtn x = ofN n
h))

lemma sub_val_p_mul: ∀ {p : R} (evr : EnatValRing p) (x : R) (n : ℕ), sub_val evr (p ^ n * x) n = x
sub_val_p_mul {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.20549} → R → [inst : IntegralDomain R] → Type ?u.20549
EnatValRing p: R
p) (x: R
x : R: Type u
R) (n: ℕ
n : ℕ: Type
ℕ) : sub_val: {R : Type ?u.20562} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr (p: R
p ^ n: ℕ
n * x: R
x) n: ℕ
n = x: R
x := by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

sub_val evr (p ^ n * x) n = xinduction n: ℕ
n with
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

sub_val evr (p ^ n * x) n = x| zero: ℕ
zero      =>
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

zerosub_val evr (p ^ Nat.zero * x) Nat.zero = xrw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

zerosub_val evr (p ^ Nat.zero * x) Nat.zero = xpow_zero: ∀ {M : Type ?u.20810} [inst : Monoid M] (a : M), a ^ 0 = 1
pow_zero,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

zerosub_val evr (1 * x) Nat.zero = x R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

zerosub_val evr (p ^ Nat.zero * x) Nat.zero = xone_mul: ∀ {M : Type ?u.20899} [inst : MulOneClass M] (a : M), 1 * a = a
one_mulR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

zerosub_val evr x Nat.zero = x]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

zerosub_val evr x Nat.zero = x
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

zerosub_val evr (p ^ Nat.zero * x) Nat.zero = xexact sub_val_x_zero: ∀ {R : Type ?u.20999} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R), sub_val evr x 0 = x
sub_val_x_zero evr: EnatValRing p
evr x: R
x
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

sub_val evr (p ^ n * x) n = x| succ: ℕ → ℕ
succ n: ℕ
n ih: ?m.20804 n
ih =>
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succsub_val evr (p ^ Nat.succ n * x) (Nat.succ n) = xrw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succsub_val evr (p ^ Nat.succ n * x) (Nat.succ n) = xsub_val_val_pos_succ: ∀ {R : Type ?u.21022} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x ≠ 0 → sub_val evr x (Nat.succ m) = sub_val evr (decr_val evr x) m
sub_val_val_pos_succ evr: EnatValRing p
evr,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succsub_val evr (decr_val evr (p ^ Nat.succ n * x)) n = x
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.hSurjVal.v evr.valtn (p ^ Nat.succ n * x) ≠ 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succsub_val evr (p ^ Nat.succ n * x) (Nat.succ n) = xpow_succ: ∀ {M : Type ?u.21044} [inst : Monoid M] (a : M) (n : ℕ), a ^ (n + 1) = a * a ^ n
pow_succ,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succsub_val evr (decr_val evr (p * p ^ n * x)) n = x
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.hSurjVal.v evr.valtn (p ^ Nat.succ n * x) ≠ 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succsub_val evr (p ^ Nat.succ n * x) (Nat.succ n) = xmul_assoc: ∀ {G : Type ?u.21102} [inst : Semigroup G] (a b c : G), a * b * c = a * (b * c)
mul_assoc,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succsub_val evr (decr_val evr (p * (p ^ n * x))) n = x
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.hSurjVal.v evr.valtn (p ^ Nat.succ n * x) ≠ 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succsub_val evr (p ^ Nat.succ n * x) (Nat.succ n) = xdecr_val_p_mul: ∀ {R : Type ?u.21200} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R), decr_val evr (p * x) = x
decr_val_p_mulR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succsub_val evr (p ^ n * x) n = x
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.hSurjVal.v evr.valtn (p ^ Nat.succ n * x) ≠ 0]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succsub_val evr (p ^ n * x) n = x
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.hSurjVal.v evr.valtn (p ^ Nat.succ n * x) ≠ 0
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succsub_val evr (p ^ Nat.succ n * x) (Nat.succ n) = xexact ih: ?m.20804 n
ihR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.hSurjVal.v evr.valtn (p ^ Nat.succ n * x) ≠ 0
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succsub_val evr (p ^ Nat.succ n * x) (Nat.succ n) = xapply ne_of_gt: ∀ {α : Type ?u.21227} [inst : Preorder α] {a b : α}, b < a → a ≠ b
ne_of_gtR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.h.h0 < SurjVal.v evr.valtn (p ^ Nat.succ n * x)
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succsub_val evr (p ^ Nat.succ n * x) (Nat.succ n) = xapply lt_of_succ_le: ∀ {n : ℕ} {m : ℕ∪∞}, succ (ofN n) ≤ m → ofN n < m
lt_of_succ_leR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.h.h.hsucc (ofN Nat.zero) ≤ SurjVal.v evr.valtn (p ^ Nat.succ n * x)
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succsub_val evr (p ^ Nat.succ n * x) (Nat.succ n) = xrw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.h.h.hsucc (ofN Nat.zero) ≤ SurjVal.v evr.valtn (p ^ Nat.succ n * x)pow_succ: ∀ {M : Type ?u.21257} [inst : Monoid M] (a : M) (n : ℕ), a ^ (n + 1) = a * a ^ n
pow_succ,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.h.h.hsucc (ofN Nat.zero) ≤ SurjVal.v evr.valtn (p * p ^ n * x) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.h.h.hsucc (ofN Nat.zero) ≤ SurjVal.v evr.valtn (p ^ Nat.succ n * x)mul_assoc: ∀ {G : Type ?u.21315} [inst : Semigroup G] (a b c : G), a * b * c = a * (b * c)
mul_assoc,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.h.h.hsucc (ofN Nat.zero) ≤ SurjVal.v evr.valtn (p * (p ^ n * x)) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.h.h.hsucc (ofN Nat.zero) ≤ SurjVal.v evr.valtn (p ^ Nat.succ n * x)succ_ofN: ∀ (a : ℕ), succ (ofN a) = ofN (Nat.succ a)
succ_ofN,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.h.h.hofN (Nat.succ Nat.zero) ≤ SurjVal.v evr.valtn (p * (p ^ n * x)) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.h.h.hsucc (ofN Nat.zero) ≤ SurjVal.v evr.valtn (p ^ Nat.succ n * x)←evr: EnatValRing p
evr.valtn: {R : Type ?u.21390} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v_uniformizer: ∀ {R : Type ?u.21394} {p : R} [inst : IntegralDomain R] (self : SurjVal p), SurjVal.v self p = ofN 1
v_uniformizerR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.h.h.hSurjVal.v evr.valtn p ≤ SurjVal.v evr.valtn (p * (p ^ n * x))]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.h.h.hSurjVal.v evr.valtn p ≤ SurjVal.v evr.valtn (p * (p ^ n * x))
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succsub_val evr (p ^ Nat.succ n * x) (Nat.succ n) = xapply val_mul_ge_left: ∀ {R : Type ?u.21408} [inst : IntegralDomain R] {p : R} (nav : SurjVal p) (a b : R),
  SurjVal.v nav (a * b) ≥ SurjVal.v nav a
val_mul_ge_left evr: EnatValRing p
evr.valtn: {R : Type ?u.21412} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn
Goals accomplished! 🐙

lemma sub_val_neg: ∀ {R : Type u} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x : R} {n : ℕ},
  sub_val evr (-x) n = -sub_val evr x n
sub_val_neg {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.21467} → R → [inst : IntegralDomain R] → Type ?u.21467
EnatValRing p: R
p) {x: R
x : R: Type u
R} {n: ℕ
n : ℕ: Type
ℕ} : sub_val: {R : Type ?u.21480} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr (-x: R
x) n: ℕ
n = -sub_val: {R : Type ?u.21515} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x n: ℕ
n := by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

sub_val evr (-x) n = -sub_val evr x ninduction n: ℕ
n with
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

sub_val evr (-x) n = -sub_val evr x n| zero: ℕ
zero => R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

zerosub_val evr (-x) Nat.zero = -sub_val evr x Nat.zerosimp [sub_val_x_zero: ∀ {R : Type ?u.21550} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R), sub_val evr x 0 = x
sub_val_x_zero]
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

sub_val evr (-x) n = -sub_val evr x n| succ: ℕ → ℕ
succ n: ℕ
n ih: ?m.21544 n
ih =>
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

succsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)cases eq_zero_or_pos: ∀ (n : ℕ∪∞), n = ofN 0 ∨ n > ofN 0
eq_zero_or_pos (evr: EnatValRing p
evr.valtn: {R : Type ?u.21660} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.21664} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x) with
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

x✝: SurjVal.v evr.valtn x = ofN 0 ∨ SurjVal.v evr.valtn x > ofN 0

succsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)| inl: ∀ {a b : Prop}, a → a ∨ b
inl h': ?m.21692
h' =>
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x = ofN 0

succ.inlsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)have h'm: SurjVal.v evr.valtn (-x) = ofN 0
h'm : evr: EnatValRing p
evr.valtn: {R : Type ?u.21724} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.21728} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (-x: R
x) = ofN: ℕ → ℕ∪∞
ofN 0: ?m.21736
0 := R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x = ofN 0

succ.inlsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)by R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x = ofN 0

SurjVal.v evr.valtn (-x) = ofN 0simp [h': SurjVal.v evr.valtn x = ofN 0
h']
Goals accomplished! 🐙
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x = ofN 0

succ.inlsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x = ofN 0

h'm: SurjVal.v evr.valtn (-x) = ofN 0

succ.inlsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)sub_val_val_zero: ∀ {R : Type ?u.21914} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x = 0 → sub_val evr x m = x
sub_val_val_zero evr: EnatValRing p
evr _: ?m.21915
_ _: ℕ
_ h': ?m.21692
h',R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x = ofN 0

h'm: SurjVal.v evr.valtn (-x) = ofN 0

succ.inlsub_val evr (-x) (Nat.succ n) = -x R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x = ofN 0

h'm: SurjVal.v evr.valtn (-x) = ofN 0

succ.inlsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)sub_val_val_zero: ∀ {R : Type ?u.21932} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x = 0 → sub_val evr x m = x
sub_val_val_zero evr: EnatValRing p
evr _: ?m.21933
_ _: ℕ
_ h'm: SurjVal.v evr.valtn (-x) = ofN 0
h'mR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x = ofN 0

h'm: SurjVal.v evr.valtn (-x) = ofN 0

succ.inl-x = -x]
Goals accomplished! 🐙
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

x✝: SurjVal.v evr.valtn x = ofN 0 ∨ SurjVal.v evr.valtn x > ofN 0

succsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)| inr: ∀ {a b : Prop}, b → a ∨ b
inr h': ?m.21693
h' =>
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x > ofN 0

succ.inrsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)have h'm: SurjVal.v evr.valtn (-x) > ofN 0
h'm : evr: EnatValRing p
evr.valtn: {R : Type ?u.21965} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.21969} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (-x: R
x) > ofN: ℕ → ℕ∪∞
ofN 0: ?m.21977
0 := R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x > ofN 0

succ.inrsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)by R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x > ofN 0

SurjVal.v evr.valtn (-x) > ofN 0simp [h': SurjVal.v evr.valtn x > ofN 0
h']
Goals accomplished! 🐙
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x > ofN 0

succ.inrsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x > ofN 0

h'm: SurjVal.v evr.valtn (-x) > ofN 0

succ.inrsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)sub_val_val_pos_succ: ∀ {R : Type ?u.22120} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x ≠ 0 → sub_val evr x (Nat.succ m) = sub_val evr (decr_val evr x) m
sub_val_val_pos_succ evr: EnatValRing p
evr _: ?m.22121
_ _: ℕ
_ (ne_of_gt: ∀ {α : Type ?u.22129} [inst : Preorder α] {a b : α}, b < a → a ≠ b
ne_of_gt h': ?m.21693
h'),R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x > ofN 0

h'm: SurjVal.v evr.valtn (-x) > ofN 0

succ.inrsub_val evr (-x) (Nat.succ n) = -sub_val evr (decr_val evr x) n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x > ofN 0

h'm: SurjVal.v evr.valtn (-x) > ofN 0

succ.inrsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)sub_val_val_pos_succ: ∀ {R : Type ?u.22149} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x ≠ 0 → sub_val evr x (Nat.succ m) = sub_val evr (decr_val evr x) m
sub_val_val_pos_succ evr: EnatValRing p
evr _: ?m.22150
_ _: ℕ
_ (ne_of_gt: ∀ {α : Type ?u.22158} [inst : Preorder α] {a b : α}, b < a → a ≠ b
ne_of_gt h'm: SurjVal.v evr.valtn (-x) > ofN 0
h'm),R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x > ofN 0

h'm: SurjVal.v evr.valtn (-x) > ofN 0

succ.inrsub_val evr (decr_val evr (-x)) n = -sub_val evr (decr_val evr x) n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x > ofN 0

h'm: SurjVal.v evr.valtn (-x) > ofN 0

succ.inrsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)sub_val_decr_val_comm: ∀ {R : Type ?u.22168} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (n : ℕ),
  sub_val evr (decr_val evr x) n = decr_val evr (sub_val evr x n)
sub_val_decr_val_comm,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x > ofN 0

h'm: SurjVal.v evr.valtn (-x) > ofN 0

succ.inrdecr_val evr (sub_val evr (-x) n) = -sub_val evr (decr_val evr x) n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x > ofN 0

h'm: SurjVal.v evr.valtn (-x) > ofN 0

succ.inrsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)ih: ?m.21544 n
ih,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x > ofN 0

h'm: SurjVal.v evr.valtn (-x) > ofN 0

succ.inrdecr_val evr (-sub_val evr x n) = -sub_val evr (decr_val evr x) n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x > ofN 0

h'm: SurjVal.v evr.valtn (-x) > ofN 0

succ.inrsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)decr_val_neg: ∀ {R : Type ?u.22193} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R),
  decr_val evr (-x) = -decr_val evr x
decr_val_neg,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x > ofN 0

h'm: SurjVal.v evr.valtn (-x) > ofN 0

succ.inr-decr_val evr (sub_val evr x n) = -sub_val evr (decr_val evr x) n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x > ofN 0

h'm: SurjVal.v evr.valtn (-x) > ofN 0

succ.inrsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)sub_val_decr_val_comm: ∀ {R : Type ?u.22207} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (n : ℕ),
  sub_val evr (decr_val evr x) n = decr_val evr (sub_val evr x n)
sub_val_decr_val_commR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x > ofN 0

h'm: SurjVal.v evr.valtn (-x) > ofN 0

succ.inr-decr_val evr (sub_val evr x n) = -decr_val evr (sub_val evr x n)]
Goals accomplished! 🐙

lemma sub_val_add: ∀ {p : R} (evr : EnatValRing p) {x y : R} {n : ℕ},
  SurjVal.v evr.valtn x ≥ ofN n →
    SurjVal.v evr.valtn y ≥ ofN n → sub_val evr (x + y) n = sub_val evr x n + sub_val evr y n
sub_val_add {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.22264} → R → [inst : IntegralDomain R] → Type ?u.22264
EnatValRing p: R
p) {x: R
x y: R
y : R: Type u
R} {n: ℕ
n : ℕ: Type
ℕ} (hx: SurjVal.v evr.valtn x ≥ ofN n
hx : evr: EnatValRing p
evr.valtn: {R : Type ?u.22279} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.22286} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x ≥ ofN: ℕ → ℕ∪∞
ofN n: ℕ
n)
  (hy: SurjVal.v evr.valtn y ≥ ofN n
hy : evr: EnatValRing p
evr.valtn: {R : Type ?u.22301} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.22305} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v y: R
y ≥ ofN: ℕ → ℕ∪∞
ofN n: ℕ
n) : sub_val: {R : Type ?u.22314} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr (x: R
x + y: R
y) n: ℕ
n = sub_val: {R : Type ?u.22421} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x n: ℕ
n + sub_val: {R : Type ?u.22428} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr y: R
y n: ℕ
n := by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr (x + y) n = sub_val evr x n + sub_val evr y napply nzero_mul_left_cancel: ∀ {R : Type ?u.22489} [inst : IntegralDomain R] (a b c : R), a ≠ 0 → a * b = a * c → b = c
nzero_mul_left_cancel (p: R
p ^ n: ℕ
n)R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

ap ^ n ≠ 0
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

ap ^ n * sub_val evr (x + y) n = p ^ n * (sub_val evr x n + sub_val evr y n)
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr (x + y) n = sub_val evr x n + sub_val evr y n.R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

ap ^ n ≠ 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

ap ^ n ≠ 0
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

ap ^ n * sub_val evr (x + y) n = p ^ n * (sub_val evr x n + sub_val evr y n)exact pow_nonzero: ∀ {R : Type ?u.22626} [inst : IntegralDomain R] (a : R) (n : ℕ), a ≠ 0 → a ^ n ≠ 0
pow_nonzero p: R
p n: ℕ
n (p_non_zero: ∀ {R : Type ?u.22650} [inst : IntegralDomain R] {p : R}, SurjVal p → ¬p = 0
p_non_zero evr: EnatValRing p
evr.valtn: {R : Type ?u.22665} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn)
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr (x + y) n = sub_val evr x n + sub_val evr y n.R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

ap ^ n * sub_val evr (x + y) n = p ^ n * (sub_val evr x n + sub_val evr y n) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

ap ^ n * sub_val evr (x + y) n = p ^ n * (sub_val evr x n + sub_val evr y n)rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

ap ^ n * sub_val evr (x + y) n = p ^ n * (sub_val evr x n + sub_val evr y n)←factor_p_of_le_val: ∀ {R : Type ?u.22671} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x : R} {n : ℕ},
  SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n
factor_p_of_le_val evr: EnatValRing p
evr (_: SurjVal.v evr.valtn (x + y) ≥ ofN n
_ : evr: EnatValRing p
evr.valtn: {R : Type ?u.22682} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.22686} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (x: R
x + y: R
y) ≥ ofN: ℕ → ℕ∪∞
ofN n: ℕ
n),R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

ax + y = p ^ n * (sub_val evr x n + sub_val evr y n)
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

SurjVal.v evr.valtn (x + y) ≥ ofN n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

ap ^ n * sub_val evr (x + y) n = p ^ n * (sub_val evr x n + sub_val evr y n)mul_add: ∀ {R : Type ?u.22764} [inst : Distrib R] (a b c : R), a * (b + c) = a * b + a * c
mul_add,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

ax + y = p ^ n * sub_val evr x n + p ^ n * sub_val evr y n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

SurjVal.v evr.valtn (x + y) ≥ ofN n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

ap ^ n * sub_val evr (x + y) n = p ^ n * (sub_val evr x n + sub_val evr y n)←factor_p_of_le_val: ∀ {R : Type ?u.22855} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x : R} {n : ℕ},
  SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n
factor_p_of_le_val evr: EnatValRing p
evr hx: SurjVal.v evr.valtn x ≥ ofN n
hx,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

ax + y = x + p ^ n * sub_val evr y n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

SurjVal.v evr.valtn (x + y) ≥ ofN n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

ap ^ n * sub_val evr (x + y) n = p ^ n * (sub_val evr x n + sub_val evr y n)←factor_p_of_le_val: ∀ {R : Type ?u.22873} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x : R} {n : ℕ},
  SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n
factor_p_of_le_val evr: EnatValRing p
evr hy: SurjVal.v evr.valtn y ≥ ofN n
hyR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

ax + y = x + y
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

SurjVal.v evr.valtn (x + y) ≥ ofN n]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

SurjVal.v evr.valtn (x + y) ≥ ofN n
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

ap ^ n * sub_val evr (x + y) n = p ^ n * (sub_val evr x n + sub_val evr y n)exact Enat.le_trans: ∀ {n m k : ℕ∪∞}, n ≤ m → m ≤ k → n ≤ k
Enat.le_trans (le_min: ∀ {α : Type ?u.22896} [inst : LinearOrder α] {a b c : α}, c ≤ a → c ≤ b → c ≤ min a b
le_min hx: SurjVal.v evr.valtn x ≥ ofN n
hx hy: SurjVal.v evr.valtn y ≥ ofN n
hy) (evr: EnatValRing p
evr.valtn: {R : Type ?u.22903} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v_add_ge_min_v: ∀ {R : Type ?u.22907} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a b : R),
  SurjVal.v self (a + b) ≥ min (SurjVal.v self a) (SurjVal.v self b)
v_add_ge_min_v x: R
x y: R
y)
Goals accomplished! 🐙

lemma sub_val_sub: ∀ {p : R} (evr : EnatValRing p) {x y : R} {n : ℕ},
  SurjVal.v evr.valtn x ≥ ofN n →
    SurjVal.v evr.valtn y ≥ ofN n → sub_val evr (x - y) n = sub_val evr x n - sub_val evr y n
sub_val_sub {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.22932} → R → [inst : IntegralDomain R] → Type ?u.22932
EnatValRing p: R
p) {x: R
x y: R
y : R: Type u
R} {n: ℕ
n : ℕ: Type
ℕ} (hx: SurjVal.v evr.valtn x ≥ ofN n
hx : evr: EnatValRing p
evr.valtn: {R : Type ?u.22947} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.22954} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x ≥ ofN: ℕ → ℕ∪∞
ofN n: ℕ
n)
  (hy: SurjVal.v evr.valtn y ≥ ofN n
hy : evr: EnatValRing p
evr.valtn: {R : Type ?u.22969} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.22973} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v y: R
y ≥ ofN: ℕ → ℕ∪∞
ofN n: ℕ
n) : sub_val: {R : Type ?u.22982} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr (x: R
x - y: R
y) n: ℕ
n = sub_val: {R : Type ?u.23053} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x n: ℕ
n - sub_val: {R : Type ?u.23060} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr y: R
y n: ℕ
n :=
by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr (x - y) n = sub_val evr x n - sub_val evr y nrw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr (x - y) n = sub_val evr x n - sub_val evr y nsub_eq_add_neg: ∀ {G : Type ?u.23107} [inst : SubNegMonoid G] (a b : G), a - b = a + -b
sub_eq_add_neg,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr (x + -y) n = sub_val evr x n - sub_val evr y n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr (x - y) n = sub_val evr x n - sub_val evr y nsub_eq_add_neg: ∀ {G : Type ?u.23203} [inst : SubNegMonoid G] (a b : G), a - b = a + -b
sub_eq_add_neg,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr (x + -y) n = sub_val evr x n + -sub_val evr y n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr (x - y) n = sub_val evr x n - sub_val evr y nsub_val_add: ∀ {R : Type ?u.23257} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x y : R} {n : ℕ},
  SurjVal.v evr.valtn x ≥ ofN n →
    SurjVal.v evr.valtn y ≥ ofN n → sub_val evr (x + y) n = sub_val evr x n + sub_val evr y n
sub_val_add evr: EnatValRing p
evr hx: SurjVal.v evr.valtn x ≥ ofN n
hx,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr x n + sub_val evr (-y) n = sub_val evr x n + -sub_val evr y n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

SurjVal.v evr.valtn (-y) ≥ ofN n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr (x - y) n = sub_val evr x n - sub_val evr y nsub_val_neg: ∀ {R : Type ?u.23296} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x : R} {n : ℕ},
  sub_val evr (-x) n = -sub_val evr x n
sub_val_negR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr x n + -sub_val evr y n = sub_val evr x n + -sub_val evr y n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

SurjVal.v evr.valtn (-y) ≥ ofN n]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

SurjVal.v evr.valtn (-y) ≥ ofN n
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr (x - y) n = sub_val evr x n - sub_val evr y nsimpa
Goals accomplished! 🐙

lemma sub_val_mul_left: ∀ {R : Type u} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x y : R} {n : ℕ},
  SurjVal.v evr.valtn x ≥ ofN n → sub_val evr (x * y) n = sub_val evr x n * y
sub_val_mul_left {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.23625} → R → [inst : IntegralDomain R] → Type ?u.23625
EnatValRing p: R
p) {x: R
x y: R
y : R: Type u
R} {n: ℕ
n : ℕ: Type
ℕ} (hx: SurjVal.v evr.valtn x ≥ ofN n
hx : evr: EnatValRing p
evr.valtn: {R : Type ?u.23640} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.23647} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x ≥ ofN: ℕ → ℕ∪∞
ofN n: ℕ
n) :
  sub_val: {R : Type ?u.23662} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr (x: R
x * y: R
y) n: ℕ
n = sub_val: {R : Type ?u.23765} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x n: ℕ
n * y: R
y := by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

sub_val evr (x * y) n = sub_val evr x n * yapply nzero_mul_left_cancel: ∀ {R : Type ?u.23824} [inst : IntegralDomain R] (a b c : R), a ≠ 0 → a * b = a * c → b = c
nzero_mul_left_cancel (p: R
p ^ n: ℕ
n)R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

ap ^ n ≠ 0
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

ap ^ n * sub_val evr (x * y) n = p ^ n * (sub_val evr x n * y)
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

sub_val evr (x * y) n = sub_val evr x n * y.R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

ap ^ n ≠ 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

ap ^ n ≠ 0
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

ap ^ n * sub_val evr (x * y) n = p ^ n * (sub_val evr x n * y)exact pow_nonzero: ∀ {R : Type ?u.23961} [inst : IntegralDomain R] (a : R) (n : ℕ), a ≠ 0 → a ^ n ≠ 0
pow_nonzero p: R
p n: ℕ
n (p_non_zero: ∀ {R : Type ?u.23985} [inst : IntegralDomain R] {p : R}, SurjVal p → ¬p = 0
p_non_zero evr: EnatValRing p
evr.valtn: {R : Type ?u.24000} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn)
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

sub_val evr (x * y) n = sub_val evr x n * y.R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

ap ^ n * sub_val evr (x * y) n = p ^ n * (sub_val evr x n * y) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

ap ^ n * sub_val evr (x * y) n = p ^ n * (sub_val evr x n * y)rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

ap ^ n * sub_val evr (x * y) n = p ^ n * (sub_val evr x n * y)←factor_p_of_le_val: ∀ {R : Type ?u.24006} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x : R} {n : ℕ},
  SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n
factor_p_of_le_val evr: EnatValRing p
evr (_: SurjVal.v evr.valtn (x * y) ≥ ofN n
_ : evr: EnatValRing p
evr.valtn: {R : Type ?u.24017} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.24021} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (x: R
x * y: R
y) ≥ ofN: ℕ → ℕ∪∞
ofN n: ℕ
n),R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

ax * y = p ^ n * (sub_val evr x n * y)
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

SurjVal.v evr.valtn (x * y) ≥ ofN n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

ap ^ n * sub_val evr (x * y) n = p ^ n * (sub_val evr x n * y)←mul_assoc: ∀ {G : Type ?u.24104} [inst : Semigroup G] (a b c : G), a * b * c = a * (b * c)
mul_assoc,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

ax * y = p ^ n * sub_val evr x n * y
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

SurjVal.v evr.valtn (x * y) ≥ ofN n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

ap ^ n * sub_val evr (x * y) n = p ^ n * (sub_val evr x n * y)←factor_p_of_le_val: ∀ {R : Type ?u.24216} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x : R} {n : ℕ},
  SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n
factor_p_of_le_val evr: EnatValRing p
evr hx: SurjVal.v evr.valtn x ≥ ofN n
hxR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

ax * y = x * y
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

SurjVal.v evr.valtn (x * y) ≥ ofN n]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

SurjVal.v evr.valtn (x * y) ≥ ofN n
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

ap ^ n * sub_val evr (x * y) n = p ^ n * (sub_val evr x n * y)exact Enat.le_trans: ∀ {n m k : ℕ∪∞}, n ≤ m → m ≤ k → n ≤ k
Enat.le_trans hx: SurjVal.v evr.valtn x ≥ ofN n
hx (val_mul_ge_left: ∀ {R : Type ?u.24239} [inst : IntegralDomain R] {p : R} (nav : SurjVal p) (a b : R),
  SurjVal.v nav (a * b) ≥ SurjVal.v nav a
val_mul_ge_left evr: EnatValRing p
evr.valtn: {R : Type ?u.24243} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn x: R
x y: R
y)
Goals accomplished! 🐙

lemma sub_val_mul_right: ∀ {p : R} (evr : EnatValRing p) {x y : R} {n : ℕ},
  SurjVal.v evr.valtn y ≥ ofN n → sub_val evr (x * y) n = x * sub_val evr y n
sub_val_mul_right {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.24269} → R → [inst : IntegralDomain R] → Type ?u.24269
EnatValRing p: R
p) {x: R
x y: R
y : R: Type u
R} {n: ℕ
n : ℕ: Type
ℕ} (hy: SurjVal.v evr.valtn y ≥ ofN n
hy : evr: EnatValRing p
evr.valtn: {R : Type ?u.24284} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.24291} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v y: R
y ≥ ofN: ℕ → ℕ∪∞
ofN n: ℕ
n) :
  sub_val: {R : Type ?u.24306} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr (x: R
x * y: R
y) n: ℕ
n = x: R
x * sub_val: {R : Type ?u.24409} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr y: R
y n: ℕ
n :=
by R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr (x * y) n = x * sub_val evr y nrw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr (x * y) n = x * sub_val evr y nmul_comm: ∀ {G : Type ?u.24468} [inst : CommSemigroup G] (a b : G), a * b = b * a
mul_comm x: R
x y: R
y,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr (y * x) n = x * sub_val evr y n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr (x * y) n = x * sub_val evr y nsub_val_mul_left: ∀ {R : Type ?u.24504} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x y : R} {n : ℕ},
  SurjVal.v evr.valtn x ≥ ofN n → sub_val evr (x * y) n = sub_val evr x n * y
sub_val_mul_left evr: EnatValRing p
evr hy: SurjVal.v evr.valtn y ≥ ofN n
hy,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr y n * x = x * sub_val evr y n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr (x * y) n = x * sub_val evr y nmul_comm: ∀ {G : Type ?u.24533} [inst : CommSemigroup G] (a b : G), a * b = b * a
mul_commR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hy: SurjVal.v evr.valtn y ≥ ofN n

x * sub_val evr y n = x * sub_val evr y n]
Goals accomplished! 🐙

lemma sub_val_mul_sub_val: ∀ {p : R} (evr : EnatValRing p) {x y : R} (n m : ℕ),
  SurjVal.v evr.valtn x ≥ ofN n →
    SurjVal.v evr.valtn y ≥ ofN m → sub_val evr x n * sub_val evr y m = sub_val evr (x * y) (n + m)
sub_val_mul_sub_val {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.24592} → R → [inst : IntegralDomain R] → Type ?u.24592
EnatValRing p: R
p) {x: R
x y: R
y : R: Type u
R} (n: ℕ
n m: ℕ
m : ℕ: Type
ℕ)
  (hx: SurjVal.v evr.valtn x ≥ ofN n
hx : evr: EnatValRing p
evr.valtn: {R : Type ?u.24609} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.24616} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x ≥ ofN: ℕ → ℕ∪∞
ofN n: ℕ
n) (hy: SurjVal.v evr.valtn y ≥ ofN m
hy : evr: EnatValRing p
evr.valtn: {R : Type ?u.24631} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.24635} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v y: R
y ≥ ofN: ℕ → ℕ∪∞
ofN m: ℕ
m) :
  sub_val: {R : Type ?u.24647} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x n: ℕ
n * sub_val: {R : Type ?u.24654} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr y: R
y m: ℕ
m = sub_val: {R : Type ?u.24661} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr (x: R
x * y: R
y) (n: ℕ
n + m: ℕ
m) := by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

sub_val evr x n * sub_val evr y m = sub_val evr (x * y) (n + m)apply nzero_mul_left_cancel: ∀ {R : Type ?u.24855} [inst : IntegralDomain R] (a b c : R), a ≠ 0 → a * b = a * c → b = c
nzero_mul_left_cancel (p: R
p ^ (n: ℕ
n + m: ℕ
m)) _: ?m.24856
_ _: ?m.24856
_ (pow_nonzero: ∀ {R : Type ?u.25003} [inst : IntegralDomain R] (a : R) (n : ℕ), a ≠ 0 → a ^ n ≠ 0
pow_nonzero p: R
p _: ℕ
_ (p_non_zero: ∀ {R : Type ?u.25037} [inst : IntegralDomain R] {p : R}, SurjVal p → ¬p = 0
p_non_zero evr: EnatValRing p
evr.valtn: {R : Type ?u.25046} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn))R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ (n + m) * (sub_val evr x n * sub_val evr y m) = p ^ (n + m) * sub_val evr (x * y) (n + m)
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

sub_val evr x n * sub_val evr y m = sub_val evr (x * y) (n + m)rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ (n + m) * (sub_val evr x n * sub_val evr y m) = p ^ (n + m) * sub_val evr (x * y) (n + m)←factor_p_of_le_val: ∀ {R : Type ?u.25055} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x : R} {n : ℕ},
  SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n
factor_p_of_le_val evr: EnatValRing p
evr (_: SurjVal.v evr.valtn (x * y) ≥ ofN (n + m)
_ : evr: EnatValRing p
evr.valtn: {R : Type ?u.25066} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.25070} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (x: R
x * y: R
y) ≥ ofN: ℕ → ℕ∪∞
ofN (n: ℕ
n + m: ℕ
m)),R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ (n + m) * (sub_val evr x n * sub_val evr y m) = x * y
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ (n + m) * (sub_val evr x n * sub_val evr y m) = p ^ (n + m) * sub_val evr (x * y) (n + m)pow_add: ∀ {M : Type ?u.25177} [inst : Monoid M] (a : M) (m n : ℕ), a ^ (m + n) = a ^ m * a ^ n
pow_add,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ n * p ^ m * (sub_val evr x n * sub_val evr y m) = x * y
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ (n + m) * (sub_val evr x n * sub_val evr y m) = p ^ (n + m) * sub_val evr (x * y) (n + m)mul_assoc: ∀ {G : Type ?u.25271} [inst : Semigroup G] (a b c : G), a * b * c = a * (b * c)
mul_assoc,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ n * (p ^ m * (sub_val evr x n * sub_val evr y m)) = x * y
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m)
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ (n + m) * (sub_val evr x n * sub_val evr y m) = p ^ (n + m) * sub_val evr (x * y) (n + m)mul_comm: ∀ {G : Type ?u.25371} [inst : CommSemigroup G] (a b : G), a * b = b * a
mul_comm (p: R
p ^ m: ℕ
m),R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ n * (sub_val evr x n * sub_val evr y m * p ^ m) = x * y
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ (n + m) * (sub_val evr x n * sub_val evr y m) = p ^ (n + m) * sub_val evr (x * y) (n + m)← mul_assoc: ∀ {G : Type ?u.25459} [inst : Semigroup G] (a b c : G), a * b * c = a * (b * c)
mul_assoc,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ n * (sub_val evr x n * sub_val evr y m) * p ^ m = x * y
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m)
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ (n + m) * (sub_val evr x n * sub_val evr y m) = p ^ (n + m) * sub_val evr (x * y) (n + m)← mul_assoc: ∀ {G : Type ?u.25530} [inst : Semigroup G] (a b c : G), a * b * c = a * (b * c)
mul_assoc,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ n * sub_val evr x n * sub_val evr y m * p ^ m = x * y
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m)
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ (n + m) * (sub_val evr x n * sub_val evr y m) = p ^ (n + m) * sub_val evr (x * y) (n + m)←factor_p_of_le_val: ∀ {R : Type ?u.25610} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x : R} {n : ℕ},
  SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n
factor_p_of_le_val evr: EnatValRing p
evr (_: SurjVal.v evr.valtn x ≥ ofN n
_ : evr: EnatValRing p
evr.valtn: {R : Type ?u.25621} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.25625} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x ≥ ofN: ℕ → ℕ∪∞
ofN n: ℕ
n),R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

x * sub_val evr y m * p ^ m = x * y
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ (n + m) * (sub_val evr x n * sub_val evr y m) = p ^ (n + m) * sub_val evr (x * y) (n + m)mul_assoc: ∀ {G : Type ?u.25635} [inst : Semigroup G] (a b c : G), a * b * c = a * (b * c)
mul_assoc,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

x * (sub_val evr y m * p ^ m) = x * y
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ (n + m) * (sub_val evr x n * sub_val evr y m) = p ^ (n + m) * sub_val evr (x * y) (n + m)mul_comm: ∀ {G : Type ?u.25703} [inst : CommSemigroup G] (a b : G), a * b = b * a
mul_comm _: ?m.25704
_ (p: R
p ^ m: ℕ
m),R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

x * (p ^ m * sub_val evr y m) = x * y
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m)
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ (n + m) * (sub_val evr x n * sub_val evr y m) = p ^ (n + m) * sub_val evr (x * y) (n + m)←factor_p_of_le_val: ∀ {R : Type ?u.25760} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x : R} {n : ℕ},
  SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n
factor_p_of_le_val evr: EnatValRing p
evr (_: SurjVal.v evr.valtn y ≥ ofN m
_ : evr: EnatValRing p
evr.valtn: {R : Type ?u.25771} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.25775} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v y: R
y ≥ ofN: ℕ → ℕ∪∞
ofN m: ℕ
m)R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

x * y = x * y
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn y ≥ ofN m
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m)]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn y ≥ ofN m
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m)
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

sub_val evr x n * sub_val evr y m = sub_val evr (x * y) (n + m).R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn y ≥ ofN m R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn y ≥ ofN m
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m)assumption
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

sub_val evr x n * sub_val evr y m = sub_val evr (x * y) (n + m).R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn x ≥ ofN n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m)assumption
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

sub_val evr x n * sub_val evr y m = sub_val evr (x * y) (n + m).R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m)rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m)SurjVal.v_mul_eq_add_v: ∀ {R : Type ?u.25792} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a b : R),
  SurjVal.v self (a * b) = SurjVal.v self a + SurjVal.v self b
SurjVal.v_mul_eq_add_v,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn x + SurjVal.v evr.valtn y ≥ ofN (n + m) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m)← add_ofN: ∀ (a b : ℕ), ofN a + ofN b = ofN (a + b)
add_ofNR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn x + SurjVal.v evr.valtn y ≥ ofN n + ofN m]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn x + SurjVal.v evr.valtn y ≥ ofN n + ofN m
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m)exact add_le_add: ∀ {a b c d : ℕ∪∞}, a ≤ b → c ≤ d → a + c ≤ b + d
add_le_add hx: SurjVal.v evr.valtn x ≥ ofN n
hx hy: SurjVal.v evr.valtn y ≥ ofN m
hy
Goals accomplished! 🐙

lemma sub_val_mul: ∀ {R : Type u} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x y : R} (n m : ℕ) {nm : ℕ},
  n + m = nm →
    SurjVal.v evr.valtn x ≥ ofN n →
      SurjVal.v evr.valtn y ≥ ofN m → sub_val evr (x * y) nm = sub_val evr x n * sub_val evr y m
sub_val_mul {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.25874} → R → [inst : IntegralDomain R] → Type ?u.25874
EnatValRing p: R
p) {x: R
x y: R
y : R: Type u
R} (n: ℕ
n m: ℕ
m : ℕ: Type
ℕ) {nm: ℕ
nm : ℕ: Type
ℕ} (h: n + m = nm
h : n: ℕ
n + m: ℕ
m = nm: ℕ
nm)
  (hx: SurjVal.v evr.valtn x ≥ ofN n
hx : evr: EnatValRing p
evr.valtn: {R : Type ?u.25937} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.25944} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x ≥ ofN: ℕ → ℕ∪∞
ofN n: ℕ
n) (hy: SurjVal.v evr.valtn y ≥ ofN m
hy : evr: EnatValRing p
evr.valtn: {R : Type ?u.25959} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.25963} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v y: R
y ≥ ofN: ℕ → ℕ∪∞
ofN m: ℕ
m) :
  sub_val: {R : Type ?u.25972} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr (x: R
x * y: R
y) nm: ℕ
nm = sub_val: {R : Type ?u.26075} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x n: ℕ
n * sub_val: {R : Type ?u.26082} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr y: R
y m: ℕ
m := by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m, nm: ℕ

h: n + m = nm

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

sub_val evr (x * y) nm = sub_val evr x n * sub_val evr y mrw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m, nm: ℕ

h: n + m = nm

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

sub_val evr (x * y) nm = sub_val evr x n * sub_val evr y m← h: n + m = nm
h,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m, nm: ℕ

h: n + m = nm

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

sub_val evr (x * y) (n + m) = sub_val evr x n * sub_val evr y m R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m, nm: ℕ

h: n + m = nm

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

sub_val evr (x * y) nm = sub_val evr x n * sub_val evr y msub_val_mul_sub_val: ∀ {R : Type ?u.26148} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x y : R} (n m : ℕ),
  SurjVal.v evr.valtn x ≥ ofN n →
    SurjVal.v evr.valtn y ≥ ofN m → sub_val evr x n * sub_val evr y m = sub_val evr (x * y) (n + m)
sub_val_mul_sub_val _: EnatValRing ?m.26151
_ _: ℕ
_ _: ℕ
_ hx: SurjVal.v evr.valtn x ≥ ofN n
hx hy: SurjVal.v evr.valtn y ≥ ofN m
hyR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m, nm: ℕ

h: n + m = nm

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

sub_val evr (x * y) (n + m) = sub_val evr (x * y) (n + m)]
Goals accomplished! 🐙

lemma sub_val_pow: ∀ {R : Type u} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x : R} (n k : ℕ) {nm : ℕ},
  k * n = nm → SurjVal.v evr.valtn x ≥ ofN n → sub_val evr (x ^ k) nm = sub_val evr x n ^ k
sub_val_pow {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.26211} → R → [inst : IntegralDomain R] → Type ?u.26211
EnatValRing p: R
p) {x: R
x : R: Type u
R} (n: ℕ
n k: ℕ
k : ℕ: Type
ℕ) {nm: ℕ
nm : ℕ: Type
ℕ} (h: k * n = nm
h : k: ℕ
k * n: ℕ
n = nm: ℕ
nm)
  (hx: SurjVal.v evr.valtn x ≥ ofN n
hx : evr: EnatValRing p
evr.valtn: {R : Type ?u.26276} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.26283} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x ≥ ofN: ℕ → ℕ∪∞
ofN n: ℕ
n) :
  sub_val: {R : Type ?u.26298} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr (x: R
x ^ k: ℕ
k) nm: ℕ
nm = sub_val: {R : Type ?u.26438} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x n: ℕ
n ^ k: ℕ
k := by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, k, nm: ℕ

h: k * n = nm

hx: SurjVal.v evr.valtn x ≥ ofN n

sub_val evr (x ^ k) nm = sub_val evr x n ^ kinduction k: ℕ
k generalizing nm: ℕ
nm with
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, k, nm: ℕ

h: k * n = nm

hx: SurjVal.v evr.valtn x ≥ ofN n

sub_val evr (x ^ k) nm = sub_val evr x n ^ k| zero: ℕ
zero => R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

nm: ℕ

h: Nat.zero * n = nm

zerosub_val evr (x ^ Nat.zero) nm = sub_val evr x n ^ Nat.zerosimp [← h: Nat.zero * n = nm
h]
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, k, nm: ℕ

h: k * n = nm

hx: SurjVal.v evr.valtn x ≥ ofN n

sub_val evr (x ^ k) nm = sub_val evr x n ^ k| succ: ℕ → ℕ
succ k: ℕ
k ih: ?m.26514 k
ih =>
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succsub_val evr (x ^ Nat.succ k) nm = sub_val evr x n ^ Nat.succ krw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succsub_val evr (x ^ Nat.succ k) nm = sub_val evr x n ^ Nat.succ kpow_succ: ∀ {M : Type ?u.26769} [inst : Monoid M] (a : M) (n : ℕ), a ^ (n + 1) = a * a ^ n
pow_succ,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succsub_val evr (x * x ^ k) nm = sub_val evr x n ^ Nat.succ k R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succsub_val evr (x ^ Nat.succ k) nm = sub_val evr x n ^ Nat.succ ksub_val_mul: ∀ {R : Type ?u.26827} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x y : R} (n m : ℕ) {nm : ℕ},
  n + m = nm →
    SurjVal.v evr.valtn x ≥ ofN n →
      SurjVal.v evr.valtn y ≥ ofN m → sub_val evr (x * y) nm = sub_val evr x n * sub_val evr y m
sub_val_mul _: EnatValRing ?m.26830
_ n: ℕ
n (k: ℕ
k * n: ℕ
n),R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succsub_val evr x n * sub_val evr (x ^ k) (k * n) = sub_val evr x n ^ Nat.succ k
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hn + k * n = nm
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hxSurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hySurjVal.v evr.valtn (x ^ k) ≥ ofN (k * n) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succsub_val evr (x ^ Nat.succ k) nm = sub_val evr x n ^ Nat.succ kpow_succ: ∀ {M : Type ?u.26881} [inst : Monoid M] (a : M) (n : ℕ), a ^ (n + 1) = a * a ^ n
pow_succ,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succsub_val evr x n * sub_val evr (x ^ k) (k * n) = sub_val evr x n * sub_val evr x n ^ k
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hn + k * n = nm
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hxSurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hySurjVal.v evr.valtn (x ^ k) ≥ ofN (k * n) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succsub_val evr (x ^ Nat.succ k) nm = sub_val evr x n ^ Nat.succ k← ih: ?m.26514 k
ihR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succsub_val evr x n * sub_val evr (x ^ k) (k * n) = sub_val evr x n * sub_val evr (x ^ k) ?m.26951
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succk * n = ?m.26951
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

ℕ
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hn + k * n = nm
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hxSurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hySurjVal.v evr.valtn (x ^ k) ≥ ofN (k * n)]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succk * n = k * n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hn + k * n = nm
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hxSurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hySurjVal.v evr.valtn (x ^ k) ≥ ofN (k * n)
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succsub_val evr (x ^ Nat.succ k) nm = sub_val evr x n ^ Nat.succ krflR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hn + k * n = nm
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hxSurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hySurjVal.v evr.valtn (x ^ k) ≥ ofN (k * n)
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succsub_val evr (x ^ Nat.succ k) nm = sub_val evr x n ^ Nat.succ krw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hn + k * n = nm
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hxSurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hySurjVal.v evr.valtn (x ^ k) ≥ ofN (k * n)← h: Nat.succ k * n = nm
h,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hn + k * n = Nat.succ k * n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hxSurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hySurjVal.v evr.valtn (x ^ k) ≥ ofN (k * n) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hn + k * n = nm
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hxSurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hySurjVal.v evr.valtn (x ^ k) ≥ ofN (k * n)Nat.succ_mul: ∀ (n m : ℕ), Nat.succ n * m = n * m + m
Nat.succ_mul,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hn + k * n = k * n + n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hxSurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hySurjVal.v evr.valtn (x ^ k) ≥ ofN (k * n) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hn + k * n = nm
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hxSurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hySurjVal.v evr.valtn (x ^ k) ≥ ofN (k * n)add_comm: ∀ {G : Type ?u.26975} [inst : AddCommSemigroup G] (a b : G), a + b = b + a
add_commR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hk * n + n = k * n + n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hxSurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hySurjVal.v evr.valtn (x ^ k) ≥ ofN (k * n)]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hxSurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hySurjVal.v evr.valtn (x ^ k) ≥ ofN (k * n)
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succsub_val evr (x ^ Nat.succ k) nm = sub_val evr x n ^ Nat.succ kexact hx: SurjVal.v evr.valtn x ≥ ofN n
hxR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hySurjVal.v evr.valtn (x ^ k) ≥ ofN (k * n)
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succsub_val evr (x ^ Nat.succ k) nm = sub_val evr x n ^ Nat.succ kconvert val_pow_ge_of_ge: ∀ {R : Type ?u.27053} [inst : IntegralDomain R] {m : ℕ∪∞} {p : R} (nav : SurjVal p) {a : R} (k : ℕ),
  SurjVal.v nav a ≥ m → SurjVal.v nav (a ^ k) ≥ k • m
val_pow_ge_of_ge evr: EnatValRing p
evr.valtn: {R : Type ?u.27058} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn k: ℕ
k hx: SurjVal.v evr.valtn x ≥ ofN n
hxR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

e_bofN (k * n) = k • ofN n
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succsub_val evr (x ^ Nat.succ k) nm = sub_val evr x n ^ Nat.succ kexact Enat.ofN_mul_eq_smul: ∀ (a b : ℕ), ofN (a * b) = a • ofN b
Enat.ofN_mul_eq_smul _: ℕ
_ _: ℕ
_
Goals accomplished! 🐙

lemma sub_val_sub_val: ∀ {R : Type u} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x : R} {m n : ℕ},
  sub_val evr (sub_val evr x m) n = sub_val evr x (m + n)
sub_val_sub_val {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.27271} → R → [inst : IntegralDomain R] → Type ?u.27271
EnatValRing p: R
p) {x: R
x : R: Type u
R} {m: ℕ
m n: ℕ
n : ℕ: Type
ℕ} : sub_val: {R : Type ?u.27286} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr (sub_val: {R : Type ?u.27296} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x m: ℕ
m) n: ℕ
n = sub_val: {R : Type ?u.27300} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x (m: ℕ
m + n: ℕ
n) := by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m, n: ℕ

sub_val evr (sub_val evr x m) n = sub_val evr x (m + n)have general: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)
general : ∀ y: R
y : R: Type u
R, sub_val: {R : Type ?u.27361} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr (sub_val: {R : Type ?u.27368} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr y: R
y m: ℕ
m) n: ℕ
n = sub_val: {R : Type ?u.27372} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr y: R
y (m: ℕ
m + n: ℕ
n) := R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m, n: ℕ

sub_val evr (sub_val evr x m) n = sub_val evr x (m + n)by
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m, n: ℕ

∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)induction m: ℕ
m with
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m, n: ℕ

∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)| zero: ℕ
zero => R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

zero∀ (y : R), sub_val evr (sub_val evr y Nat.zero) n = sub_val evr y (Nat.zero + n)simp [sub_val_x_zero: ∀ {R : Type ?u.27427} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R), sub_val evr x 0 = x
sub_val_x_zero]
Goals accomplished! 🐙
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m, n: ℕ

∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)| succ: ℕ → ℕ
succ m: ℕ
m ih: ?m.27420 m
ih =>
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

ih: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)

succ∀ (y : R), sub_val evr (sub_val evr y (Nat.succ m)) n = sub_val evr y (Nat.succ m + n)intro y: R
yR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

ih: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)

y: R

succsub_val evr (sub_val evr y (Nat.succ m)) n = sub_val evr y (Nat.succ m + n)
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

ih: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)

succ∀ (y : R), sub_val evr (sub_val evr y (Nat.succ m)) n = sub_val evr y (Nat.succ m + n)cases eq_zero_or_pos: ∀ (n : ℕ∪∞), n = ofN 0 ∨ n > ofN 0
eq_zero_or_pos (evr: EnatValRing p
evr.valtn: {R : Type ?u.27754} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.27758} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v y: R
y) with
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

ih: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)

y: R

x✝: SurjVal.v evr.valtn y = ofN 0 ∨ SurjVal.v evr.valtn y > ofN 0

succsub_val evr (sub_val evr y (Nat.succ m)) n = sub_val evr y (Nat.succ m + n)| inl: ∀ {a b : Prop}, a → a ∨ b
inl h': ?m.27786
h' => R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

ih: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)

y: R

h': SurjVal.v evr.valtn y = ofN 0

succ.inlsub_val evr (sub_val evr y (Nat.succ m)) n = sub_val evr y (Nat.succ m + n)simp [sub_val_val_zero: ∀ {R : Type ?u.27817} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x = 0 → sub_val evr x m = x
sub_val_val_zero evr: EnatValRing p
evr y: R
y _: ℕ
_ h': ?m.27786
h']
Goals accomplished! 🐙
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

ih: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)

y: R

x✝: SurjVal.v evr.valtn y = ofN 0 ∨ SurjVal.v evr.valtn y > ofN 0

succsub_val evr (sub_val evr y (Nat.succ m)) n = sub_val evr y (Nat.succ m + n)| inr: ∀ {a b : Prop}, b → a ∨ b
inr h': ?m.27787
h' =>
        R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

ih: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)

y: R

h': SurjVal.v evr.valtn y > ofN 0

succ.inrsub_val evr (sub_val evr y (Nat.succ m)) n = sub_val evr y (Nat.succ m + n)rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

ih: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)

y: R

h': SurjVal.v evr.valtn y > ofN 0

succ.inrsub_val evr (sub_val evr y (Nat.succ m)) n = sub_val evr y (Nat.succ m + n)sub_val_val_pos_succ: ∀ {R : Type ?u.27862} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x ≠ 0 → sub_val evr x (Nat.succ m) = sub_val evr (decr_val evr x) m
sub_val_val_pos_succ evr: EnatValRing p
evr y: R
y m: ℕ
m (ne_of_gt: ∀ {α : Type ?u.27869} [inst : Preorder α] {a b : α}, b < a → a ≠ b
ne_of_gt h': ?m.27787
h'),R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

ih: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)

y: R

h': SurjVal.v evr.valtn y > ofN 0

succ.inrsub_val evr (sub_val evr (decr_val evr y) m) n = sub_val evr y (Nat.succ m + n) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

ih: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)

y: R

h': SurjVal.v evr.valtn y > ofN 0

succ.inrsub_val evr (sub_val evr y (Nat.succ m)) n = sub_val evr y (Nat.succ m + n)Nat.succ_add: ∀ (n m : ℕ), Nat.succ n + m = Nat.succ (n + m)
Nat.succ_add,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

ih: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)

y: R

h': SurjVal.v evr.valtn y > ofN 0

succ.inrsub_val evr (sub_val evr (decr_val evr y) m) n = sub_val evr y (Nat.succ (m + n)) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

ih: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)

y: R

h': SurjVal.v evr.valtn y > ofN 0

succ.inrsub_val evr (sub_val evr y (Nat.succ m)) n = sub_val evr y (Nat.succ m + n)sub_val_val_pos_succ: ∀ {R : Type ?u.27898} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x ≠ 0 → sub_val evr x (Nat.succ m) = sub_val evr (decr_val evr x) m
sub_val_val_pos_succ evr: EnatValRing p
evr y: R
y _: ℕ
_ (ne_of_gt: ∀ {α : Type ?u.27906} [inst : Preorder α] {a b : α}, b < a → a ≠ b
ne_of_gt h': ?m.27787
h')R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

ih: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)

y: R

h': SurjVal.v evr.valtn y > ofN 0

succ.inrsub_val evr (sub_val evr (decr_val evr y) m) n = sub_val evr (decr_val evr y) (m + n)]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

ih: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)

y: R

h': SurjVal.v evr.valtn y > ofN 0

succ.inrsub_val evr (sub_val evr (decr_val evr y) m) n = sub_val evr (decr_val evr y) (m + n)
        R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

ih: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)

y: R

h': SurjVal.v evr.valtn y > ofN 0

succ.inrsub_val evr (sub_val evr y (Nat.succ m)) n = sub_val evr y (Nat.succ m + n)exact ih: ?m.27420 m
ih (evr: EnatValRing p
evr.decr_val: {R : Type ?u.27920} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val y: R
y)
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m, n: ℕ

sub_val evr (sub_val evr x m) n = sub_val evr x (m + n)exact general: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)
general x: R
x
Goals accomplished! 🐙

def has_double_root: {p : R} → (evr : EnatValRing p) → (a b c : R) → ?m.27986 evr a b c
has_double_root {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.27971} → R → [inst : IntegralDomain R] → Type ?u.27971
EnatValRing p: R
p) (a: R
a b: R
b c: R
c : R: Type u
R) :=
  evr: EnatValRing p
evr.valtn: {R : Type ?u.28007} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.28011} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v a: R
a = 0: ?m.28019
0 ∧ evr: EnatValRing p
evr.valtn: {R : Type ?u.28249} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.28253} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (b: R
b ^ 2: ?m.28264
2 - 4: ?m.28280
4 * a: R
a * c: R
c) > 0: ?m.28593
0

end EnatValRing


def nat_prime: ℕ → Prop
nat_prime (p: ℕ
p : ℕ: Type
ℕ) : Prop: Type
Prop := 1: ?m.28888
1 < p: ℕ
p ∧ (∀ a: ℕ
a b: ℕ
b : ℕ: Type
ℕ, (a: ℕ
a * b: ℕ
b) % p: ℕ
p = 0: ?m.28935
0 → a: ℕ
a % p: ℕ
p = 0: ?m.29033
0 ∨ b: ℕ
b % p: ℕ
p = 0: ?m.29072
0)

lemma ndiv_mul_left: ∀ (a b p : ℕ), a * b % p ≠ 0 → a % p ≠ 0
ndiv_mul_left (a: ℕ
a b: ℕ
b p: ℕ
p : ℕ: Type
ℕ) : (a: ℕ
a * b: ℕ
b) % p: ℕ
p ≠ 0: ?m.29211
0 → a: ℕ
a % p: ℕ
p ≠ 0: ?m.29246
0 := by
  R: Type u

inst✝: IntegralDomain R

a, b, p: ℕ

a * b % p ≠ 0 → a % p ≠ 0intro hab: a * b % p ≠ 0
hab ha: a % p = 0
haR: Type u

inst✝: IntegralDomain R

a, b, p: ℕ

hab: a * b % p ≠ 0

ha: a % p = 0

False
  R: Type u

inst✝: IntegralDomain R

a, b, p: ℕ

a * b % p ≠ 0 → a % p ≠ 0apply hab: a * b % p ≠ 0
habR: Type u

inst✝: IntegralDomain R

a, b, p: ℕ

hab: a * b % p ≠ 0

ha: a % p = 0

a * b % p = 0
  R: Type u

inst✝: IntegralDomain R

a, b, p: ℕ

a * b % p ≠ 0 → a % p ≠ 0simp [Nat.mul_mod: ∀ (a b n : ℕ), a * b % n = a % n * (b % n) % n
Nat.mul_mod, ha: a % p = 0
ha]
Goals accomplished! 🐙

lemma ndiv_mul_right: ∀ (a b p : ℕ), a * b % p ≠ 0 → b % p ≠ 0
ndiv_mul_right (a: ℕ
a b: ℕ
b p: ℕ
p : ℕ: Type
ℕ) : (a: ℕ
a * b: ℕ
b) % p: ℕ
p ≠ 0: ?m.29510
0 → b: ℕ
b % p: ℕ
p ≠ 0: ?m.29545
0 := by
  R: Type u

inst✝: IntegralDomain R

a, b, p: ℕ

a * b % p ≠ 0 → b % p ≠ 0rw [R: Type u

inst✝: IntegralDomain R

a, b, p: ℕ

a * b % p ≠ 0 → b % p ≠ 0Nat.mul_comm: ∀ (n m : ℕ), n * m = m * n
Nat.mul_commR: Type u

inst✝: IntegralDomain R

a, b, p: ℕ

b * a % p ≠ 0 → b % p ≠ 0]R: Type u

inst✝: IntegralDomain R

a, b, p: ℕ

b * a % p ≠ 0 → b % p ≠ 0
  R: Type u

inst✝: IntegralDomain R

a, b, p: ℕ

a * b % p ≠ 0 → b % p ≠ 0exact ndiv_mul_left: ∀ (a b p : ℕ), a * b % p ≠ 0 → a % p ≠ 0
ndiv_mul_left b: ℕ
b a: ℕ
a p: ℕ
p
Goals accomplished! 🐙

lemma nat_prime_test: ∀ (p : ℕ), nat_prime p ↔ 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0
nat_prime_test (p: ℕ
p : ℕ: Type
ℕ) : nat_prime: ℕ → Prop
nat_prime p: ℕ
p ↔ (1: ?m.29598
1 < p: ℕ
p ∧ (∀ a: ℕ
a b: ℕ
b : ℕ: Type
ℕ, a: ℕ
a < p: ℕ
p → b: ℕ
b < p: ℕ
p → (a: ℕ
a * b: ℕ
b) % p: ℕ
p = 0: ?m.29655
0 → a: ℕ
a % p: ℕ
p = 0: ?m.29753
0 ∨ b: ℕ
b % p: ℕ
p = 0: ?m.29792
0)) := by
  R: Type u

inst✝: IntegralDomain R

p: ℕ

nat_prime p ↔ 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0apply Iff.intro: ∀ {a b : Prop}, (a → b) → (b → a) → (a ↔ b)
Iff.introR: Type u

inst✝: IntegralDomain R

p: ℕ

mpnat_prime p → 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0
R: Type u

inst✝: IntegralDomain R

p: ℕ

mpr(1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0) → nat_prime p
  R: Type u

inst✝: IntegralDomain R

p: ℕ

nat_prime p ↔ 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0.R: Type u

inst✝: IntegralDomain R

p: ℕ

mpnat_prime p → 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0 R: Type u

inst✝: IntegralDomain R

p: ℕ

mpnat_prime p → 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0
R: Type u

inst✝: IntegralDomain R

p: ℕ

mpr(1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0) → nat_prime pintro H: ?a
HR: Type u

inst✝: IntegralDomain R

p: ℕ

H: nat_prime p

mp1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0
    R: Type u

inst✝: IntegralDomain R

p: ℕ

mpnat_prime p → 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0
R: Type u

inst✝: IntegralDomain R

p: ℕ

mpr(1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0) → nat_prime papply And.intro: ∀ {a b : Prop}, a → b → a ∧ b
And.intro (H: ?a
H.left: ∀ {a b : Prop}, a ∧ b → a
left)R: Type u

inst✝: IntegralDomain R

p: ℕ

H: nat_prime p

mp∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0
    R: Type u

inst✝: IntegralDomain R

p: ℕ

mpnat_prime p → 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0
R: Type u

inst✝: IntegralDomain R

p: ℕ

mpr(1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0) → nat_prime pintro a: ℕ
a b: ℕ
b _: a < p
_ _: b < p
_R: Type u

inst✝: IntegralDomain R

p: ℕ

H: nat_prime p

a, b: ℕ

a✝¹: a < p

a✝: b < p

mpa * b % p = 0 → a % p = 0 ∨ b % p = 0
    R: Type u

inst✝: IntegralDomain R

p: ℕ

mpnat_prime p → 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0
R: Type u

inst✝: IntegralDomain R

p: ℕ

mpr(1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0) → nat_prime papply H: ?a
H.right: ∀ {a b : Prop}, a ∧ b → b
right a: ℕ
a b: ℕ
b
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: ℕ

nat_prime p ↔ 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0.R: Type u

inst✝: IntegralDomain R

p: ℕ

mpr(1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0) → nat_prime p R: Type u

inst✝: IntegralDomain R

p: ℕ

mpr(1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0) → nat_prime pintro H: ?b
HR: Type u

inst✝: IntegralDomain R

p: ℕ

H: 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0

mprnat_prime p
    R: Type u

inst✝: IntegralDomain R

p: ℕ

mpr(1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0) → nat_prime papply And.intro: ∀ {a b : Prop}, a → b → a ∧ b
And.intro (H: ?b
H.left: ∀ {a b : Prop}, a ∧ b → a
left)R: Type u

inst✝: IntegralDomain R

p: ℕ

H: 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0

mpr∀ (a b : ℕ), a * b % p = 0 → a % p = 0 ∨ b % p = 0
    R: Type u

inst✝: IntegralDomain R

p: ℕ

mpr(1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0) → nat_prime pintro a: ℕ
a b: ℕ
b p_div_ab: a * b % p = 0
p_div_abR: Type u

inst✝: IntegralDomain R

p: ℕ

H: 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0

a, b: ℕ

p_div_ab: a * b % p = 0

mpra % p = 0 ∨ b % p = 0
    R: Type u

inst✝: IntegralDomain R

p: ℕ

mpr(1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0) → nat_prime prw [R: Type u

inst✝: IntegralDomain R

p: ℕ

H: 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0

a, b: ℕ

p_div_ab: a * b % p = 0

mpra % p = 0 ∨ b % p = 0Nat.mul_mod: ∀ (a b n : ℕ), a * b % n = a % n * (b % n) % n
Nat.mul_modR: Type u

inst✝: IntegralDomain R

p: ℕ

H: 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0

a, b: ℕ

p_div_ab: a % p * (b % p) % p = 0

mpra % p = 0 ∨ b % p = 0]R: Type u

inst✝: IntegralDomain R

p: ℕ

H: 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0

a, b: ℕ

p_div_ab: a % p * (b % p) % p = 0

mpra % p = 0 ∨ b % p = 0 at p_div_ab: a * b % p = 0
p_div_abR: Type u

inst✝: IntegralDomain R

p: ℕ

H: 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0

a, b: ℕ

p_div_ab: a % p * (b % p) % p = 0

mpra % p = 0 ∨ b % p = 0
    R: Type u

inst✝: IntegralDomain R

p: ℕ

mpr(1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0) → nat_prime phave p_pos: p > 0
p_pos : p: ℕ
p > 0: ?m.29939
0 := lt_trans: ∀ {α : Type ?u.29956} [inst : Preorder α] {a b c : α}, a < b → b < c → a < c
lt_trans Nat.zero_lt_one: 0 < 1
Nat.zero_lt_one H: ?b
H.left: ∀ {a b : Prop}, a ∧ b → a
leftR: Type u

inst✝: IntegralDomain R

p: ℕ

H: 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0

a, b: ℕ

p_div_ab: a % p * (b % p) % p = 0

p_pos: p > 0

mpra % p = 0 ∨ b % p = 0;R: Type u

inst✝: IntegralDomain R

p: ℕ

H: 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0

a, b: ℕ

p_div_ab: a % p * (b % p) % p = 0

p_pos: p > 0

mpra % p = 0 ∨ b % p = 0
    R: Type u

inst✝: IntegralDomain R

p: ℕ

mpr(1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0) → nat_prime phave h: ?m.29985
h := H: ?b
H.right: ∀ {a b : Prop}, a ∧ b → b
right (a: ℕ
a % p: ℕ
p) (b: ℕ
b % p: ℕ
p) (Nat.mod_lt: ∀ (x : ℕ) {y : ℕ}, y > 0 → x % y < y
Nat.mod_lt a: ℕ
a p_pos: p > 0
p_pos) (Nat.mod_lt: ∀ (x : ℕ) {y : ℕ}, y > 0 → x % y < y
Nat.mod_lt b: ℕ
b p_pos: p > 0
p_pos) p_div_ab: a % p * (b % p) % p = 0
p_div_abR: Type u

inst✝: IntegralDomain R

p: ℕ

H: 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0

a, b: ℕ

p_div_ab: a % p * (b % p) % p = 0

p_pos: p > 0

h: a % p % p = 0 ∨ b % p % p = 0

mpra % p = 0 ∨ b % p = 0;R: Type u

inst✝: IntegralDomain R

p: ℕ

H: 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0

a, b: ℕ

p_div_ab: a % p * (b % p) % p = 0

p_pos: p > 0

h: a % p % p = 0 ∨ b % p % p = 0

mpra % p = 0 ∨ b % p = 0
    R: Type u

inst✝: IntegralDomain R

p: ℕ

mpr(1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0) → nat_prime prwa [R: Type u

inst✝: IntegralDomain R

p: ℕ

H: 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0

a, b: ℕ

p_div_ab: a % p * (b % p) % p = 0

p_pos: p > 0

h: a % p % p = 0 ∨ b % p % p = 0

mpra % p = 0 ∨ b % p = 0Nat.mod_mod: ∀ (a n : ℕ), a % n % n = a % n
Nat.mod_mod _: ℕ
_ p: ℕ
p,R: Type u

inst✝: IntegralDomain R

p: ℕ

H: 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0

a, b: ℕ

p_div_ab: a % p * (b % p) % p = 0

p_pos: p > 0

h: a % p = 0 ∨ b % p % p = 0

mpra % p = 0 ∨ b % p = 0 R: Type u

inst✝: IntegralDomain R

p: ℕ

H: 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0

a, b: ℕ

p_div_ab: a % p * (b % p) % p = 0

p_pos: p > 0

h: a % p % p = 0 ∨ b % p % p = 0

mpra % p = 0 ∨ b % p = 0Nat.mod_mod: ∀ (a n : ℕ), a % n % n = a % n
Nat.mod_mod _: ℕ
_ p: ℕ
pR: Type u

inst✝: IntegralDomain R

p: ℕ

H: 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0

a, b: ℕ

p_div_ab: a % p * (b % p) % p = 0

p_pos: p > 0

h: a % p = 0 ∨ b % p = 0

mpra % p = 0 ∨ b % p = 0]R: Type u

inst✝: IntegralDomain R

p: ℕ

H: 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0

a, b: ℕ

p_div_ab: a % p * (b % p) % p = 0

p_pos: p > 0

h: a % p = 0 ∨ b % p = 0

mpra % p = 0 ∨ b % p = 0 at h: ?m.29985
h
Goals accomplished! 🐙



instance: DecidablePred fun x => nat_prime x
instanceWarning: declaration uses 'sorry' : DecidablePred: {α : Sort ?u.30118} → (α → Prop) → Sort (max 1 ?u.30118)
DecidablePred (nat_prime: ℕ → Prop
nat_prime . : ℕ: Type
ℕ → Prop: Type
Prop) := fun p: ?m.30132
p => sorry: ?m.30135
sorry
--match p with
  --| 0 => sorry --isFalse (not_and_of_not_left _ (not_lt_of_ge (le_of_lt Nat.zero_lt_one)))
  --| 1 => isFalse (not_and_of_not_left _ (not_lt_of_ge (le_of_eq rfl)))
  --| Nat.succ (Nat.succ p') => sorry



--def fmul_eq_addf {R R' : Type u} [Mul R] [Add R'] (f : R → R') (x y : R) : Prop := f (x * y) = f x + f y



namespace Int


def nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation : ℕ: Type
ℕ → ℕ: Type
ℕ → ℕ∪∞: Type
ℕ∪∞
  | _, 0: ℕ
0 => ∞: ℕ∪∞
∞
  | 0: ℕ
0, (_: ℕ
_+1) => ofN: ℕ → ℕ∪∞
ofN 0: ?m.30286
0
  | 1: ℕ
1, (_: ℕ
_+1) => ∞: ℕ∪∞
∞
  | (q: ℕ
q+2), (m: ℕ
m+1) => if (m: ℕ
m+1: ?m.30467
1) % (q: ℕ
q+2: ?m.30481
2) ≠ 0: ?m.30573
0 then ofN: ℕ → ℕ∪∞
ofN 0: ?m.30580
0 else succ: ℕ∪∞ → ℕ∪∞
succ (nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation (q: ℕ
q+2: ?m.30586
2) ((m: ℕ
m+1: ?m.30631
1) / (q: ℕ
q+2: ?m.30645
2)))
termination_by nat_valuation p k => k: ℕ
k
decreasing_by
  simp [WellFoundedRelation.rel: {α : Sort ?u.31157} → [self : WellFoundedRelation α] → α → α → Prop
WellFoundedRelation.rel, measure: {α : Sort ?u.31159} → (α → ℕ) → WellFoundedRelation α
measure, invImage: {α : Sort ?u.31162} → {β : Sort ?u.31161} → (α → β) → WellFoundedRelation β → WellFoundedRelation α
invImage, InvImage: {α : Sort ?u.31165} → {β : Sort ?u.31164} → (β → β → Prop) → (α → β) → α → α → Prop
InvImage, Nat.lt_wfRel: WellFoundedRelation ℕ
Nat.lt_wfRel]q, m: ℕ

h✝: ¬(m + 1) % (q + 2) ≠ 0

(m + 1) / (q + 2) < Nat.succ m
  q, m: ℕ

h✝: ¬(m + 1) % (q + 2) ≠ 0

(invImage (fun a => PSigma.casesOn a fun p snd => snd) instWellFoundedRelation).1
  { fst := q + 2, snd := (m + 1) / (q + 2) } { fst := Nat.succ (Nat.succ q), snd := Nat.succ m }exact Nat.div_lt_self: ∀ {n k : ℕ}, 0 < n → 1 < k → n / k < n
Nat.div_lt_self (Nat.zero_lt_succ: ∀ (n : ℕ), 0 < Nat.succ n
Nat.zero_lt_succ m: ℕ
m) (Nat.succ_lt_succ: ∀ {n m : ℕ}, n < m → Nat.succ n < Nat.succ m
Nat.succ_lt_succ (Nat.zero_lt_succ: ∀ (n : ℕ), 0 < Nat.succ n
Nat.zero_lt_succ q: ℕ
q))
Goals accomplished! 🐙

lemma nat_val_zero: ∀ (p : ℕ), nat_valuation p 0 = ∞
nat_val_zero (p: ℕ
p : ℕ: Type
ℕ) : nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation p: ℕ
p 0: ?m.32225
0 = ∞: ℕ∪∞
∞ := by
  R: Type u

inst✝: IntegralDomain R

p: ℕ

nat_valuation p 0 = ∞simp [nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation]
Goals accomplished! 🐙
lemma nat_val_succ: ∀ (q m : ℕ),
  nat_valuation (q + 2) (m + 1) =     if (m + 1) % (q + 2) ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((m + 1) / (q + 2)))
nat_val_succ (q: ℕ
q m: ℕ
m : ℕ: Type
ℕ) : nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation (q: ℕ
q+2: ?m.45419
2) (m: ℕ
m+1: ?m.45473
1) = if (m: ℕ
m+1: ?m.45534
1) % (q: ℕ
q+2: ?m.45548
2) ≠ 0: ?m.45640
0 then ofN: ℕ → ℕ∪∞
ofN 0: ?m.45651
0 else succ: ℕ∪∞ → ℕ∪∞
succ (nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation (q: ℕ
q+2: ?m.45657
2) ((m: ℕ
m+1: ?m.45702
1) / (q: ℕ
q+2: ?m.45716
2))) := by R: Type u

inst✝: IntegralDomain R

q, m: ℕ

nat_valuation (q + 2) (m + 1) =   if (m + 1) % (q + 2) ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((m + 1) / (q + 2)))rfl
Goals accomplished! 🐙


def int_val: ℕ → ℤ → ℕ∪∞
int_val (p: ℕ
p : ℕ: Type
ℕ) (k: ℤ
k : ℤ: Type
ℤ) : ℕ∪∞: Type
ℕ∪∞ :=
  nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation p: ℕ
p (natAbs: ℤ → ℕ
natAbs k: ℤ
k)

lemma int_val_uniformizer: ∀ {p : ℕ}, 1 < p → int_val p ↑p = ofN 1
int_val_uniformizer {p: ℕ
p : ℕ: Type
ℕ} (gt1: 1 < p
gt1 : 1: ?m.48737
1 < p: ℕ
p) : int_val: ℕ → ℤ → ℕ∪∞
int_val p: ℕ
p p: ℕ
p = ofN: ℕ → ℕ∪∞
ofN 1: ?m.48859
1 := by
  R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < p

int_val p ↑p = ofN 1simp only [natAbs_cast: ∀ (n : ℕ), natAbs ↑n = n
natAbs_cast, int_val: ℕ → ℤ → ℕ∪∞
int_val]R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < p

nat_valuation p p = ofN 1
  R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < p

int_val p ↑p = ofN 1match p: ℕ
p with
  R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < p

nat_valuation p p = ofN 1| 0: ℕ
0 =>R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < 0

nat_valuation 0 0 = ofN 1
    R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < p

nat_valuation p p = ofN 1apply False.elim: ∀ {C : Sort ?u.49251}, False → C
False.elimR: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < 0

hFalse
    R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < 0

nat_valuation 0 0 = ofN 1apply Nat.not_lt_zero: ∀ (n : ℕ), ¬n < 0
Nat.not_lt_zero 1: ?m.49257
1R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < 0

h1 < 0
    R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < 0

nat_valuation 0 0 = ofN 1assumption
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < p

nat_valuation p p = ofN 1| Nat.succ: ℕ → ℕ
Nat.succ 0: ℕ
0 =>R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < Nat.succ 0

nat_valuation (Nat.succ 0) (Nat.succ 0) = ofN 1
    R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < p

nat_valuation p p = ofN 1apply False.elim: ∀ {C : Sort ?u.49270}, False → C
False.elimR: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < Nat.succ 0

hFalse
    R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < Nat.succ 0

nat_valuation (Nat.succ 0) (Nat.succ 0) = ofN 1apply Nat.lt_irrefl: ∀ (n : ℕ), ¬n < n
Nat.lt_irrefl 1: ?m.49276
1R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < Nat.succ 0

h1 < 1
    R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < Nat.succ 0

nat_valuation (Nat.succ 0) (Nat.succ 0) = ofN 1assumption
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < p

nat_valuation p p = ofN 1| q: ℕ
q+2 =>R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

nat_valuation (q + 2) (q + 2) = ofN 1
    R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < p

nat_valuation p p = ofN 1rw [R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

nat_valuation (q + 2) (q + 2) = ofN 1nat_val_succ: ∀ (q m : ℕ),
  nat_valuation (q + 2) (m + 1) =     if (m + 1) % (q + 2) ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((m + 1) / (q + 2)))
nat_val_succ,R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

(if (q + 1 + 1) % (q + 2) ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((q + 1 + 1) / (q + 2)))) = ofN 1 R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

nat_valuation (q + 2) (q + 2) = ofN 1Nat.mod_self: ∀ (n : ℕ), n % n = 0
Nat.mod_self,R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

(if 0 ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((q + 1 + 1) / (q + 2)))) = ofN 1 R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

nat_valuation (q + 2) (q + 2) = ofN 1if_neg: ∀ {c : Prop} {h : Decidable c}, ¬c → ∀ {α : Sort ?u.49320} {t e : α}, (if c then t else e) = e
if_neg _: ¬?m.49321
_R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

succ (nat_valuation (q + 2) ((q + 1 + 1) / (q + 2))) = ofN 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0]R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

succ (nat_valuation (q + 2) ((q + 1 + 1) / (q + 2))) = ofN 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0
    R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

nat_valuation (q + 2) (q + 2) = ofN 1rw [R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

succ (nat_valuation (q + 2) ((q + 1 + 1) / (q + 2))) = ofN 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0Nat.div_self: ∀ {n : ℕ}, 0 < n → n / n = 1
Nat.div_self,R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

succ (nat_valuation (q + 2) 1) = ofN 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

0 < q + 1 + 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0 R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

succ (nat_valuation (q + 2) ((q + 1 + 1) / (q + 2))) = ofN 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0nat_val_succ: ∀ (q m : ℕ),
  nat_valuation (q + 2) (m + 1) =     if (m + 1) % (q + 2) ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((m + 1) / (q + 2)))
nat_val_succ,R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

succ (if (0 + 1) % (q + 2) ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((0 + 1) / (q + 2)))) = ofN 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

0 < q + 1 + 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0 R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

succ (nat_valuation (q + 2) ((q + 1 + 1) / (q + 2))) = ofN 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0if_pos: ∀ {c : Prop} {h : Decidable c}, c → ∀ {α : Sort ?u.49359} {t e : α}, (if c then t else e) = t
if_pos,R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

succ (ofN 0) = ofN 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

hc(0 + 1) % (q + 2) ≠ 0
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

0 < q + 1 + 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0 R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

succ (nat_valuation (q + 2) ((q + 1 + 1) / (q + 2))) = ofN 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0succ_ofN: ∀ (a : ℕ), succ (ofN a) = ofN (Nat.succ a)
succ_ofNR: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

ofN (Nat.succ 0) = ofN 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

hc(0 + 1) % (q + 2) ≠ 0
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

0 < q + 1 + 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0]R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

hc(0 + 1) % (q + 2) ≠ 0
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

0 < q + 1 + 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0
    R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

nat_valuation (q + 2) (q + 2) = ofN 1rw [R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

hc(0 + 1) % (q + 2) ≠ 0
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

0 < q + 1 + 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0Nat.mod_eq_of_lt: ∀ {a b : ℕ}, a < b → a % b = a
Nat.mod_eq_of_ltR: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

hc0 + 1 ≠ 0
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

hc0 + 1 < q + 2
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

0 < q + 1 + 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0]R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

hc0 + 1 ≠ 0
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

hc0 + 1 < q + 2
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

0 < q + 1 + 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0
    R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

nat_valuation (q + 2) (q + 2) = ofN 1exact Nat.succ_ne_zero: ∀ (n : ℕ), Nat.succ n ≠ 0
Nat.succ_ne_zero 0: ?m.49406
0R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

hc0 + 1 < q + 2
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

0 < q + 1 + 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0
    R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

nat_valuation (q + 2) (q + 2) = ofN 1assumptionR: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

0 < q + 1 + 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0
    R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

nat_valuation (q + 2) (q + 2) = ofN 1exact lt_trans: ∀ {α : Type ?u.49416} [inst : Preorder α] {a b c : α}, a < b → b < c → a < c
lt_trans (Nat.lt_succ_self: ∀ (n : ℕ), n < Nat.succ n
Nat.lt_succ_self 0: ?m.49439
0) gt1: 1 < q + 2
gt1R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0
    R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

nat_valuation (q + 2) (q + 2) = ofN 1exact Ne.irrefl: ∀ {α : Sort ?u.49441} {a : α}, a ≠ a → False
Ne.irrefl
Goals accomplished! 🐙

lemma nat_val_mul_eq_add: ∀ (p : ℕ), nat_prime p → ∀ (a b : ℕ), nat_valuation p (a * b) = nat_valuation p a + nat_valuation p b
nat_val_mul_eq_add (p: ℕ
p : ℕ: Type
ℕ) (prime: nat_prime p
prime : nat_prime: ℕ → Prop
nat_prime p: ℕ
p) (a: ℕ
a b: ℕ
b : ℕ: Type
ℕ) : nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation p: ℕ
p (a: ℕ
a * b: ℕ
b) = nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation p: ℕ
p a: ℕ
a + nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation p: ℕ
p b: ℕ
b := by
  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b: ℕ

nat_valuation p (a * b) = nat_valuation p a + nat_valuation p bhave general: ∀ (n c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d
general (n: ℕ
n : ℕ: Type
ℕ) : ∀ c: ?m.49573
c d: ?m.49576
d, c: ?m.49573
c + d: ?m.49576
d ≤ n: ℕ
n → nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation p: ℕ
p (c: ?m.49573
c * d: ?m.49576
d) = nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation p: ℕ
p c: ?m.49573
c + nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation p: ℕ
p d: ?m.49576
d := R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b: ℕ

nat_valuation p (a * b) = nat_valuation p a + nat_valuation p bby
    R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p dinduction n: ℕ
n with
    R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d| zero: ℕ
zero =>
      R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b: ℕ

zero∀ (c d : ℕ), c + d ≤ Nat.zero → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p dintro c: ℕ
c d: ℕ
d h_sum: c + d ≤ Nat.zero
h_sumR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, c, d: ℕ

h_sum: c + d ≤ Nat.zero

zeronat_valuation p (c * d) = nat_valuation p c + nat_valuation p d
      R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b: ℕ

zero∀ (c d : ℕ), c + d ≤ Nat.zero → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p drw [R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, c, d: ℕ

h_sum: c + d ≤ Nat.zero

zeronat_valuation p (c * d) = nat_valuation p c + nat_valuation p dNat.eq_zero_of_add_eq_zero_right: ∀ {n m : ℕ}, n + m = 0 → n = 0
Nat.eq_zero_of_add_eq_zero_right (Nat.eq_zero_of_le_zero: ∀ {n : ℕ}, n ≤ 0 → n = 0
Nat.eq_zero_of_le_zero h_sum: c + d ≤ Nat.zero
h_sum),R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, c, d: ℕ

h_sum: c + d ≤ Nat.zero

zeronat_valuation p (0 * d) = nat_valuation p 0 + nat_valuation p d R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, c, d: ℕ

h_sum: c + d ≤ Nat.zero

zeronat_valuation p (c * d) = nat_valuation p c + nat_valuation p dNat.eq_zero_of_add_eq_zero_left: ∀ {n m : ℕ}, n + m = 0 → m = 0
Nat.eq_zero_of_add_eq_zero_left (Nat.eq_zero_of_le_zero: ∀ {n : ℕ}, n ≤ 0 → n = 0
Nat.eq_zero_of_le_zero h_sum: c + d ≤ Nat.zero
h_sum)R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, c, d: ℕ

h_sum: c + d ≤ Nat.zero

zeronat_valuation p (0 * 0) = nat_valuation p 0 + nat_valuation p 0]R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, c, d: ℕ

h_sum: c + d ≤ Nat.zero

zeronat_valuation p (0 * 0) = nat_valuation p 0 + nat_valuation p 0
      R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b: ℕ

zero∀ (c d : ℕ), c + d ≤ Nat.zero → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p dsimp [nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation]
Goals accomplished! 🐙
    R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d| succ: ℕ → ℕ
succ n: ℕ
n ih: ?m.49688 n
ih =>
      R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

succ∀ (c d : ℕ), c + d ≤ Nat.succ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p dintro c: ℕ
c d: ℕ
d h_sum: c + d ≤ Nat.succ n
h_sumR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: c + d ≤ Nat.succ n

succnat_valuation p (c * d) = nat_valuation p c + nat_valuation p d
      R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

succ∀ (c d : ℕ), c + d ≤ Nat.succ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p dcases c: ℕ
c with
      R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: c + d ≤ Nat.succ n

succnat_valuation p (c * d) = nat_valuation p c + nat_valuation p d| zero: ℕ
zero => R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

d: ℕ

h_sum: Nat.zero + d ≤ Nat.succ n

succ.zeronat_valuation p (Nat.zero * d) = nat_valuation p Nat.zero + nat_valuation p dsimp [nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation]
Goals accomplished! 🐙
      R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: c + d ≤ Nat.succ n

succnat_valuation p (c * d) = nat_valuation p c + nat_valuation p d| succ: ℕ → ℕ
succ c: ℕ
c => R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

d, c: ℕ

h_sum: Nat.succ c + d ≤ Nat.succ n

succ.succnat_valuation p (Nat.succ c * d) = nat_valuation p (Nat.succ c) + nat_valuation p dcases d: ℕ
d with
        R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

d, c: ℕ

h_sum: Nat.succ c + d ≤ Nat.succ n

succ.succnat_valuation p (Nat.succ c * d) = nat_valuation p (Nat.succ c) + nat_valuation p d| zero: ℕ
zero => R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c: ℕ

h_sum: Nat.succ c + Nat.zero ≤ Nat.succ n

succ.succ.zeronat_valuation p (Nat.succ c * Nat.zero) = nat_valuation p (Nat.succ c) + nat_valuation p Nat.zerosimp [nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation]
Goals accomplished! 🐙
        R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

d, c: ℕ

h_sum: Nat.succ c + d ≤ Nat.succ n

succ.succnat_valuation p (Nat.succ c * d) = nat_valuation p (Nat.succ c) + nat_valuation p d| succ: ℕ → ℕ
succ d: ℕ
d =>
          R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

succ.succ.succnat_valuation p (Nat.succ c * Nat.succ d) = nat_valuation p (Nat.succ c) + nat_valuation p (Nat.succ d)match Nat.le.dest: ∀ {n m : ℕ}, n ≤ m → ∃ k, n + k = m
Nat.le.dest (Nat.succ_le_of_lt: ∀ {n m : ℕ}, n < m → Nat.succ n ≤ m
Nat.succ_le_of_lt prime: nat_prime p
prime.left: ∀ {a b : Prop}, a ∧ b → a
left) with
          R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

succ.succ.succnat_valuation p (Nat.succ c * Nat.succ d) = nat_valuation p (Nat.succ c) + nat_valuation p (Nat.succ d)| ⟨q: ℕ
q, hq: Nat.succ 1 + q = p
hq⟩ =>R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: Nat.succ 1 + q = p

nat_valuation p (Nat.succ c * Nat.succ d) = nat_valuation p (Nat.succ c) + nat_valuation p (Nat.succ d)
            R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

succ.succ.succnat_valuation p (Nat.succ c * Nat.succ d) = nat_valuation p (Nat.succ c) + nat_valuation p (Nat.succ d)rw [R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: Nat.succ 1 + q = p

nat_valuation p (Nat.succ c * Nat.succ d) = nat_valuation p (Nat.succ c) + nat_valuation p (Nat.succ d)(show Nat.succ: ℕ → ℕ
Nat.succ 1: ?m.50189
1 = 2: ?m.50200
2 by R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: Nat.succ 1 + q = p

nat_valuation p (Nat.succ c * Nat.succ d) = nat_valuation p (Nat.succ c) + nat_valuation p (Nat.succ d)rfl
Goals accomplished! 🐙),R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: 2 + q = p

nat_valuation p (Nat.succ c * Nat.succ d) = nat_valuation p (Nat.succ c) + nat_valuation p (Nat.succ d) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: Nat.succ 1 + q = p

nat_valuation p (Nat.succ c * Nat.succ d) = nat_valuation p (Nat.succ c) + nat_valuation p (Nat.succ d)Nat.add_comm: ∀ (n m : ℕ), n + m = m + n
Nat.add_commR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

nat_valuation p (Nat.succ c * Nat.succ d) = nat_valuation p (Nat.succ c) + nat_valuation p (Nat.succ d)]R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

nat_valuation p (Nat.succ c * Nat.succ d) = nat_valuation p (Nat.succ c) + nat_valuation p (Nat.succ d) at hq: 2 + q = p
hqR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

nat_valuation p (Nat.succ c * Nat.succ d) = nat_valuation p (Nat.succ c) + nat_valuation p (Nat.succ d)
            R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: Nat.succ 1 + q = p

nat_valuation p (Nat.succ c * Nat.succ d) = nat_valuation p (Nat.succ c) + nat_valuation p (Nat.succ d)simp only [←hq: q + 2 = p
hq, (show c: ℕ
c.succ: ℕ → ℕ
succ * d: ℕ
d.succ: ℕ → ℕ
succ = (c: ℕ
c * d: ℕ
d + c: ℕ
c + d: ℕ
d).succ: ℕ → ℕ
succ by R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

nat_valuation p (Nat.succ c * Nat.succ d) = nat_valuation p (Nat.succ c) + nat_valuation p (Nat.succ d)simp [Nat.succ_mul: ∀ (n m : ℕ), Nat.succ n * m = n * m + m
Nat.succ_mul, Nat.mul_succ: ∀ (n m : ℕ), n * Nat.succ m = n * m + n
Nat.mul_succ, Nat.add_succ: ∀ (n m : ℕ), n + Nat.succ m = Nat.succ (n + m)
Nat.add_succ]
Goals accomplished! 🐙), nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation]R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

(if (c * d + c + d + 1) % (q + 2) ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((c * d + c + d + 1) / (q + 2)))) =   (if (c + 1) % (q + 2) ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((c + 1) / (q + 2)))) +     if (d + 1) % (q + 2) ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((d + 1) / (q + 2)))
            R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: Nat.succ 1 + q = p

nat_valuation p (Nat.succ c * Nat.succ d) = nat_valuation p (Nat.succ c) + nat_valuation p (Nat.succ d)simp only [hq: q + 2 = p
hq, (show c: ℕ
c * d: ℕ
d + c: ℕ
c + d: ℕ
d + 1: ?m.50928
1 = (c: ℕ
c + 1: ?m.50950
1) * (d: ℕ
d + 1: ?m.50964
1) by R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

(if (c * d + c + d + 1) % (q + 2) ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((c * d + c + d + 1) / (q + 2)))) =   (if (c + 1) % (q + 2) ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((c + 1) / (q + 2)))) +     if (d + 1) % (q + 2) ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((d + 1) / (q + 2)))ring
Goals accomplished! 🐙)]R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

(if (c + 1) * (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) * (d + 1) / p))) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))
            R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: Nat.succ 1 + q = p

nat_valuation p (Nat.succ c * Nat.succ d) = nat_valuation p (Nat.succ c) + nat_valuation p (Nat.succ d)cases Nat.eq_zero_or_pos: ∀ (n : ℕ), n = 0 ∨ n > 0
Nat.eq_zero_or_pos ((c: ℕ
c + 1: ?m.51761
1) * (d: ℕ
d + 1: ?m.51775
1) % p: ℕ
p) with
            R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

x✝: (c + 1) * (d + 1) % p = 0 ∨ (c + 1) * (d + 1) % p > 0

(if (c + 1) * (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) * (d + 1) / p))) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))| inl: ∀ {a b : Prop}, a → a ∨ b
inl h: ?m.51947
h =>
              R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

inl(if (c + 1) * (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) * (d + 1) / p))) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))rw [R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

inl(if (c + 1) * (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) * (d + 1) / p))) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))if_neg: ∀ {c : Prop} {h : Decidable c}, ¬c → ∀ {α : Sort ?u.51977} {t e : α}, (if c then t else e) = e
if_neg (not_not_intro: ∀ {p : Prop}, p → ¬¬p
not_not_intro h: ?m.51947
h)R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))]R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))
              R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

inl(if (c + 1) * (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) * (d + 1) / p))) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))cases prime: nat_prime p
prime.2: ∀ {a b : Prop}, a ∧ b → b
2 (c: ℕ
c+1: ?m.52021
1) (d: ℕ
d+1: ?m.52061
1) h: ?m.51947
h with
              R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

x✝: (c + 1) % p = 0 ∨ (d + 1) % p = 0

inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))| inl: ∀ {a b : Prop}, a → a ∨ b
inl h': ?m.52142
h' =>
                R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))rw [R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))if_neg: ∀ {c : Prop} {h : Decidable c}, ¬c → ∀ {α : Sort ?u.52172} {t e : α}, (if c then t else e) = e
if_neg (not_not_intro: ∀ {p : Prop}, p → ¬¬p
not_not_intro h': ?m.52142
h'),R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   succ (nat_valuation p ((c + 1) / p)) + if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p)) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))←hq: q + 2 = p
hq,R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation (q + 2) ((c + 1) * (d + 1) / (q + 2))) =   succ (nat_valuation (q + 2) ((c + 1) / (q + 2))) +     if (d + 1) % (q + 2) ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((d + 1) / (q + 2))) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))←nat_val_succ: ∀ (q m : ℕ),
  nat_valuation (q + 2) (m + 1) =     if (m + 1) % (q + 2) ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((m + 1) / (q + 2)))
nat_val_succ q: ℕ
q d: ℕ
d,R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation (q + 2) ((c + 1) * (d + 1) / (q + 2))) =   succ (nat_valuation (q + 2) ((c + 1) / (q + 2))) + nat_valuation (q + 2) (d + 1) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))hq: q + 2 = p
hq,R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p ((c + 1) / p)) + nat_valuation p (d + 1) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))succ_add: ∀ (a b : ℕ∪∞), succ a + b = succ (a + b)
succ_addR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p ((c + 1) / p) + nat_valuation p (d + 1))]R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p ((c + 1) / p) + nat_valuation p (d + 1))
                R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))have sum_le_n: (c + 1) / p + (d + 1) ≤ n
sum_le_n : (c: ℕ
c + 1: ?m.52220
1) / p: ℕ
p + (d: ℕ
d + 1: ?m.52234
1) ≤ n: ℕ
n := R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p ((c + 1) / p) + nat_valuation p (d + 1))by
                  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

(c + 1) / p + (d + 1) ≤ napply Nat.le_of_lt_succ: ∀ {m n : ℕ}, m < Nat.succ n → m ≤ n
Nat.le_of_lt_succR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

a(c + 1) / p + (d + 1) < Nat.succ n
                  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

(c + 1) / p + (d + 1) ≤ napply lt_of_lt_of_le: ∀ {α : Type ?u.52379} [inst : Preorder α] {a b c : α}, a < b → b ≤ c → a < c
lt_of_lt_of_le _: ?m.52382 < ?m.52383
_ h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n
h_sumR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

(c + 1) / p + (d + 1) < Nat.succ c + Nat.succ d
                  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

(c + 1) / p + (d + 1) ≤ napply Nat.add_lt_add_right: ∀ {n m : ℕ}, n < m → ∀ (k : ℕ), n + k < m + k
Nat.add_lt_add_rightR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

h(c + 1) / p < Nat.succ c
                  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

(c + 1) / p + (d + 1) ≤ napply Nat.div_lt_self: ∀ {n k : ℕ}, 0 < n → 1 < k → n / k < n
Nat.div_lt_self _: 0 < ?m.52414
_ prime: nat_prime p
prime.1: ∀ {a b : Prop}, a ∧ b → a
1R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

0 < c + 1
                  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

(c + 1) / p + (d + 1) ≤ nrw [R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

0 < c + 1Nat.add_comm: ∀ (n m : ℕ), n + m = m + n
Nat.add_commR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

0 < 1 + c]R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

0 < 1 + c
                  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

(c + 1) / p + (d + 1) ≤ napply Nat.lt_add_right: ∀ (a b c : ℕ), a < b → a < b + c
Nat.lt_add_right 0: ?m.52437
0 1: ?m.52444
1 c: ℕ
c (Nat.lt_succ_self: ∀ (n : ℕ), n < Nat.succ n
Nat.lt_succ_self 0: ?m.52447
0)
Goals accomplished! 🐙
                R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))rw [R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

sum_le_n: (c + 1) / p + (d + 1) ≤ n

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p ((c + 1) / p) + nat_valuation p (d + 1))←ih: ?m.49688 n
ih ((c: ℕ
c + 1: ?m.52459
1) / p: ℕ
p) (d: ℕ
d + 1: ?m.52518
1) sum_le_n: (c + 1) / p + (d + 1) ≤ n
sum_le_nR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

sum_le_n: (c + 1) / p + (d + 1) ≤ n

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p ((c + 1) / p * (d + 1)))]R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

sum_le_n: (c + 1) / p + (d + 1) ≤ n

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p ((c + 1) / p * (d + 1)))
                R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))have mul_div_assoc: (c + 1) * (d + 1) / p = (c + 1) / p * (d + 1)
mul_div_assoc : (c: ℕ
c + 1: ?m.52578
1) * (d: ℕ
d + 1: ?m.52592
1) / p: ℕ
p = (c: ℕ
c + 1: ?m.52622
1) / p: ℕ
p * (d: ℕ
d + 1: ?m.52636
1) := R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

sum_le_n: (c + 1) / p + (d + 1) ≤ n

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p ((c + 1) / p * (d + 1)))by
                  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

sum_le_n: (c + 1) / p + (d + 1) ≤ n

(c + 1) * (d + 1) / p = (c + 1) / p * (d + 1)apply nat_mul_left_cancel: ∀ (a b c : ℕ), a ≠ 0 → a * b = a * c → b = c
nat_mul_left_cancel p: ℕ
p _: ℕ
_ _: ℕ
_ (ne_of_gt: ∀ {α : Type ?u.52841} [inst : Preorder α] {a b : α}, b < a → a ≠ b
ne_of_gt (Nat.lt_trans: ∀ {n m k : ℕ}, n < m → m < k → n < k
Nat.lt_trans (Nat.lt_succ_self: ∀ (n : ℕ), n < Nat.succ n
Nat.lt_succ_self 0: ?m.52854
0) prime: nat_prime p
prime.1: ∀ {a b : Prop}, a ∧ b → a
1))R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

sum_le_n: (c + 1) / p + (d + 1) ≤ n

p * ((c + 1) * (d + 1) / p) = p * ((c + 1) / p * (d + 1))
                  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

sum_le_n: (c + 1) / p + (d + 1) ≤ n

(c + 1) * (d + 1) / p = (c + 1) / p * (d + 1)rw [R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

sum_le_n: (c + 1) / p + (d + 1) ≤ n

p * ((c + 1) * (d + 1) / p) = p * ((c + 1) / p * (d + 1))Nat.mul_div_cancel': ∀ {n m : ℕ}, n ∣ m → n * (m / n) = m
Nat.mul_div_cancel' (Nat.dvd_of_mod_eq_zero: ∀ {m n : ℕ}, n % m = 0 → m ∣ n
Nat.dvd_of_mod_eq_zero h: (c + 1) * (d + 1) % p = 0
h),R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

sum_le_n: (c + 1) / p + (d + 1) ≤ n

(c + 1) * (d + 1) = p * ((c + 1) / p * (d + 1)) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

sum_le_n: (c + 1) / p + (d + 1) ≤ n

p * ((c + 1) * (d + 1) / p) = p * ((c + 1) / p * (d + 1))←mul_assoc: ∀ {G : Type ?u.52873} [inst : Semigroup G] (a b c : G), a * b * c = a * (b * c)
mul_assoc,R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

sum_le_n: (c + 1) / p + (d + 1) ≤ n

(c + 1) * (d + 1) = p * ((c + 1) / p) * (d + 1) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

sum_le_n: (c + 1) / p + (d + 1) ≤ n

p * ((c + 1) * (d + 1) / p) = p * ((c + 1) / p * (d + 1))Nat.mul_div_cancel': ∀ {n m : ℕ}, n ∣ m → n * (m / n) = m
Nat.mul_div_cancel' (Nat.dvd_of_mod_eq_zero: ∀ {m n : ℕ}, n % m = 0 → m ∣ n
Nat.dvd_of_mod_eq_zero h': (c + 1) % p = 0
h')R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

sum_le_n: (c + 1) / p + (d + 1) ≤ n

(c + 1) * (d + 1) = (c + 1) * (d + 1)]
Goals accomplished! 🐙
                R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))rw [R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

sum_le_n: (c + 1) / p + (d + 1) ≤ n

mul_div_assoc: (c + 1) * (d + 1) / p = (c + 1) / p * (d + 1)

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p ((c + 1) / p * (d + 1)))mul_div_assoc: (c + 1) * (d + 1) / p = (c + 1) / p * (d + 1)
mul_div_assocR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

sum_le_n: (c + 1) / p + (d + 1) ≤ n

mul_div_assoc: (c + 1) * (d + 1) / p = (c + 1) / p * (d + 1)

inl.inlsucc (nat_valuation p ((c + 1) / p * (d + 1))) = succ (nat_valuation p ((c + 1) / p * (d + 1)))]
Goals accomplished! 🐙
              R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

x✝: (c + 1) % p = 0 ∨ (d + 1) % p = 0

inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))| inr: ∀ {a b : Prop}, b → a ∨ b
inr h': ?m.52143
h' =>
                R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))rw [R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))if_neg: ∀ {c : Prop} {h : Decidable c}, ¬c → ∀ {α : Sort ?u.53025} {t e : α}, (if c then t else e) = e
if_neg (not_not_intro: ∀ {p : Prop}, p → ¬¬p
not_not_intro h': ?m.52143
h'),R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) + succ (nat_valuation p ((d + 1) / p)) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))←hq: q + 2 = p
hq,R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation (q + 2) ((c + 1) * (d + 1) / (q + 2))) =   (if (c + 1) % (q + 2) ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((c + 1) / (q + 2)))) +     succ (nat_valuation (q + 2) ((d + 1) / (q + 2))) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))←nat_val_succ: ∀ (q m : ℕ),
  nat_valuation (q + 2) (m + 1) =     if (m + 1) % (q + 2) ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((m + 1) / (q + 2)))
nat_val_succ q: ℕ
q c: ℕ
c,R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation (q + 2) ((c + 1) * (d + 1) / (q + 2))) =   nat_valuation (q + 2) (c + 1) + succ (nat_valuation (q + 2) ((d + 1) / (q + 2))) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))hq: q + 2 = p
hq,R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = nat_valuation p (c + 1) + succ (nat_valuation p ((d + 1) / p)) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))add_succ: ∀ (a b : ℕ∪∞), a + succ b = succ (a + b)
add_succR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p (c + 1) + nat_valuation p ((d + 1) / p))]R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p (c + 1) + nat_valuation p ((d + 1) / p))
                R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))have sum_le_n: c + 1 + (d + 1) / p ≤ n
sum_le_n : (c: ℕ
c + 1: ?m.53070
1) + (d: ℕ
d + 1: ?m.53087
1) / p: ℕ
p ≤ n: ℕ
n := R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p (c + 1) + nat_valuation p ((d + 1) / p))by
                  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

c + 1 + (d + 1) / p ≤ napply Nat.le_of_lt_succ: ∀ {m n : ℕ}, m < Nat.succ n → m ≤ n
Nat.le_of_lt_succR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

ac + 1 + (d + 1) / p < Nat.succ n
                  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

c + 1 + (d + 1) / p ≤ napply lt_of_lt_of_le: ∀ {α : Type ?u.53211} [inst : Preorder α] {a b c : α}, a < b → b ≤ c → a < c
lt_of_lt_of_le _: ?m.53214 < ?m.53215
_ h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n
h_sumR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

c + 1 + (d + 1) / p < Nat.succ c + Nat.succ d
                  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

c + 1 + (d + 1) / p ≤ napply Nat.add_lt_add_left: ∀ {n m : ℕ}, n < m → ∀ (k : ℕ), k + n < k + m
Nat.add_lt_add_leftR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

h(d + 1) / p < Nat.succ d
                  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

c + 1 + (d + 1) / p ≤ napply Nat.div_lt_self: ∀ {n k : ℕ}, 0 < n → 1 < k → n / k < n
Nat.div_lt_self _: 0 < ?m.53230
_ prime: nat_prime p
prime.1: ∀ {a b : Prop}, a ∧ b → a
1R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

0 < d + 1
                  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

c + 1 + (d + 1) / p ≤ nrw [R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

0 < d + 1Nat.add_comm: ∀ (n m : ℕ), n + m = m + n
Nat.add_commR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

0 < 1 + d]R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

0 < 1 + d
                  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

c + 1 + (d + 1) / p ≤ napply Nat.lt_add_right: ∀ (a b c : ℕ), a < b → a < b + c
Nat.lt_add_right 0: ?m.53247
0 1: ?m.53250
1 d: ℕ
d (Nat.lt_succ_self: ∀ (n : ℕ), n < Nat.succ n
Nat.lt_succ_self 0: ?m.53253
0)
Goals accomplished! 🐙
                R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))rw [R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p (c + 1) + nat_valuation p ((d + 1) / p))←ih: ?m.49688 n
ih (c: ℕ
c + 1: ?m.53260
1) ((d: ℕ
d + 1: ?m.53303
1) / p: ℕ
p) sum_le_n: c + 1 + (d + 1) / p ≤ n
sum_le_nR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p ((c + 1) * ((d + 1) / p)))]R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p ((c + 1) * ((d + 1) / p)))
                R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))have mul_div_assoc: (c + 1) * (d + 1) / p = (c + 1) * ((d + 1) / p)
mul_div_assoc : (c: ℕ
c + 1: ?m.53382
1) * (d: ℕ
d + 1: ?m.53396
1) / p: ℕ
p = (c: ℕ
c + 1: ?m.53423
1) * ((d: ℕ
d + 1: ?m.53440
1) / p: ℕ
p) := R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p ((c + 1) * ((d + 1) / p)))by
                  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

(c + 1) * (d + 1) / p = (c + 1) * ((d + 1) / p)apply nat_mul_left_cancel: ∀ (a b c : ℕ), a ≠ 0 → a * b = a * c → b = c
nat_mul_left_cancel p: ℕ
p _: ℕ
_ _: ℕ
_ (ne_of_gt: ∀ {α : Type ?u.53645} [inst : Preorder α] {a b : α}, b < a → a ≠ b
ne_of_gt (Nat.lt_trans: ∀ {n m k : ℕ}, n < m → m < k → n < k
Nat.lt_trans (Nat.lt_succ_self: ∀ (n : ℕ), n < Nat.succ n
Nat.lt_succ_self 0: ?m.53655
0) prime: nat_prime p
prime.1: ∀ {a b : Prop}, a ∧ b → a
1))R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

p * ((c + 1) * (d + 1) / p) = p * ((c + 1) * ((d + 1) / p))
                  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

(c + 1) * (d + 1) / p = (c + 1) * ((d + 1) / p)rw [R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

p * ((c + 1) * (d + 1) / p) = p * ((c + 1) * ((d + 1) / p))Nat.mul_div_cancel': ∀ {n m : ℕ}, n ∣ m → n * (m / n) = m
Nat.mul_div_cancel' (Nat.dvd_of_mod_eq_zero: ∀ {m n : ℕ}, n % m = 0 → m ∣ n
Nat.dvd_of_mod_eq_zero h: (c + 1) * (d + 1) % p = 0
h),R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

(c + 1) * (d + 1) = p * ((c + 1) * ((d + 1) / p)) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

p * ((c + 1) * (d + 1) / p) = p * ((c + 1) * ((d + 1) / p))←mul_assoc: ∀ {G : Type ?u.53670} [inst : Semigroup G] (a b c : G), a * b * c = a * (b * c)
mul_assoc,R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

(c + 1) * (d + 1) = p * (c + 1) * ((d + 1) / p) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

p * ((c + 1) * (d + 1) / p) = p * ((c + 1) * ((d + 1) / p))mul_comm: ∀ {G : Type ?u.53744} [inst : CommSemigroup G] (a b : G), a * b = b * a
mul_comm p: ℕ
p,R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

(c + 1) * (d + 1) = (c + 1) * p * ((d + 1) / p) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

p * ((c + 1) * (d + 1) / p) = p * ((c + 1) * ((d + 1) / p))mul_assoc: ∀ {G : Type ?u.53772} [inst : Semigroup G] (a b c : G), a * b * c = a * (b * c)
mul_assoc,R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

(c + 1) * (d + 1) = (c + 1) * (p * ((d + 1) / p)) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

p * ((c + 1) * (d + 1) / p) = p * ((c + 1) * ((d + 1) / p))Nat.mul_div_cancel': ∀ {n m : ℕ}, n ∣ m → n * (m / n) = m
Nat.mul_div_cancel' (Nat.dvd_of_mod_eq_zero: ∀ {m n : ℕ}, n % m = 0 → m ∣ n
Nat.dvd_of_mod_eq_zero h': (d + 1) % p = 0
h')R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

(c + 1) * (d + 1) = (c + 1) * (d + 1)]
Goals accomplished! 🐙
                R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))rw [R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

mul_div_assoc: (c + 1) * (d + 1) / p = (c + 1) * ((d + 1) / p)

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p ((c + 1) * ((d + 1) / p)))mul_div_assoc: (c + 1) * (d + 1) / p = (c + 1) * ((d + 1) / p)
mul_div_assocR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

mul_div_assoc: (c + 1) * (d + 1) / p = (c + 1) * ((d + 1) / p)

inl.inrsucc (nat_valuation p ((c + 1) * ((d + 1) / p))) = succ (nat_valuation p ((c + 1) * ((d + 1) / p)))]
Goals accomplished! 🐙
            R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

x✝: (c + 1) * (d + 1) % p = 0 ∨ (c + 1) * (d + 1) % p > 0

(if (c + 1) * (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) * (d + 1) / p))) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))| inr: ∀ {a b : Prop}, b → a ∨ b
inr h: ?m.51948
h =>
              R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p > 0

inr(if (c + 1) * (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) * (d + 1) / p))) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))have hc: ?m.53884
hc := ndiv_mul_left: ∀ (a b p : ℕ), a * b % p ≠ 0 → a % p ≠ 0
ndiv_mul_left _: ℕ
_ _: ℕ
_ _: ℕ
_ (ne_of_gt: ∀ {α : Type ?u.53889} [inst : Preorder α] {a b : α}, b < a → a ≠ b
ne_of_gt h: ?m.51948
h)R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p > 0

hc: (c + 1) % p ≠ 0

inr(if (c + 1) * (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) * (d + 1) / p))) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))
              R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p > 0

inr(if (c + 1) * (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) * (d + 1) / p))) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))have hd: ?m.53902
hd := ndiv_mul_right: ∀ (a b p : ℕ), a * b % p ≠ 0 → b % p ≠ 0
ndiv_mul_right _: ℕ
_ _: ℕ
_ _: ℕ
_ (ne_of_gt: ∀ {α : Type ?u.53907} [inst : Preorder α] {a b : α}, b < a → a ≠ b
ne_of_gt h: ?m.51948
h)R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p > 0

hc: (c + 1) % p ≠ 0

hd: (d + 1) % p ≠ 0

inr(if (c + 1) * (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) * (d + 1) / p))) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))
              R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p > 0

inr(if (c + 1) * (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) * (d + 1) / p))) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))rw [R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p > 0

hc: (c + 1) % p ≠ 0

hd: (d + 1) % p ≠ 0

inr(if (c + 1) * (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) * (d + 1) / p))) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))if_pos: ∀ {c : Prop} {h : Decidable c}, c → ∀ {α : Sort ?u.53919} {t e : α}, (if c then t else e) = t
if_pos (ne_of_gt: ∀ {α : Type ?u.53922} [inst : Preorder α] {a b : α}, b < a → a ≠ b
ne_of_gt h: ?m.51948
h),R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p > 0

hc: (c + 1) % p ≠ 0

hd: (d + 1) % p ≠ 0

inrofN 0 =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p)) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p > 0

hc: (c + 1) % p ≠ 0

hd: (d + 1) % p ≠ 0

inr(if (c + 1) * (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) * (d + 1) / p))) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))if_pos: ∀ {c : Prop} {h : Decidable c}, c → ∀ {α : Sort ?u.53947} {t e : α}, (if c then t else e) = t
if_pos hc: ?m.53884
hc,R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p > 0

hc: (c + 1) % p ≠ 0

hd: (d + 1) % p ≠ 0

inrofN 0 = ofN 0 + if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p)) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p > 0

hc: (c + 1) % p ≠ 0

hd: (d + 1) % p ≠ 0

inr(if (c + 1) * (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) * (d + 1) / p))) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))if_pos: ∀ {c : Prop} {h : Decidable c}, c → ∀ {α : Sort ?u.53961} {t e : α}, (if c then t else e) = t
if_pos hd: ?m.53902
hdR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p > 0

hc: (c + 1) % p ≠ 0

hd: (d + 1) % p ≠ 0

inrofN 0 = ofN 0 + ofN 0]R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p > 0

hc: (c + 1) % p ≠ 0

hd: (d + 1) % p ≠ 0

inrofN 0 = ofN 0 + ofN 0
              R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p > 0

inr(if (c + 1) * (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) * (d + 1) / p))) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))simp
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b: ℕ

nat_valuation p (a * b) = nat_valuation p a + nat_valuation p bapply general: ∀ (n c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d
general (a: ℕ
a + b: ℕ
b) a: ℕ
a b: ℕ
b (le_refl: ∀ {α : Type ?u.54035} [inst : Preorder α] (a : α), a ≤ a
le_refl _: ?m.54036
_)
Goals accomplished! 🐙

lemma int_val_mul_eq_add: ∀ (p : ℕ), nat_prime p → ∀ (a b : ℤ), int_val p (a * b) = int_val p a + int_val p b
int_val_mul_eq_add (p: ℕ
p : ℕ: Type
ℕ) (prime: nat_prime p
prime : nat_prime: ℕ → Prop
nat_prime p: ℕ
p) (a: ℤ
a b: ℤ
b : ℤ: Type
ℤ) : int_val: ℕ → ℤ → ℕ∪∞
int_val p: ℕ
p (a: ℤ
a * b: ℤ
b) = int_val: ℕ → ℤ → ℕ∪∞
int_val p: ℕ
p a: ℤ
a + int_val: ℕ → ℤ → ℕ∪∞
int_val p: ℕ
p b: ℤ
b := by
  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b: ℤ

int_val p (a * b) = int_val p a + int_val p bsimp [int_val: ℕ → ℤ → ℕ∪∞
int_val, natAbs_mul: ∀ (a b : ℤ), natAbs (a * b) = natAbs a * natAbs b
natAbs_mul]R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b: ℤ

nat_valuation p (natAbs a * natAbs b) = nat_valuation p (natAbs a) + nat_valuation p (natAbs b)
  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b: ℤ

int_val p (a * b) = int_val p a + int_val p bexact nat_val_mul_eq_add: ∀ (p : ℕ), nat_prime p → ∀ (a b : ℕ), nat_valuation p (a * b) = nat_valuation p a + nat_valuation p b
nat_val_mul_eq_add p: ℕ
p prime: nat_prime p
prime (natAbs: ℤ → ℕ
natAbs a: ℤ
a) (natAbs: ℤ → ℕ
natAbs b: ℤ
b)
Goals accomplished! 🐙


lemma nat_val_add_ge_min: ∀ (p a b : ℕ), nat_valuation p (a + b) ≥ min (nat_valuation p a) (nat_valuation p b)
nat_val_add_ge_minWarning: declaration uses 'sorry' (p: ℕ
p a: ℕ
a b: ℕ
b : ℕ: Type
ℕ) : nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation p: ℕ
p (a: ℕ
a + b: ℕ
b) ≥ min: {α : Type ?u.54447} → [self : Min α] → α → α → α
min (nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation p: ℕ
p a: ℕ
a) (nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation p: ℕ
p b: ℕ
b) := by R: Type u

inst✝: IntegralDomain R

p, a, b: ℕ

nat_valuation p (a + b) ≥ min (nat_valuation p a) (nat_valuation p b)sorry
Goals accomplished! 🐙

lemma natAbs_add: ∀ (a b : ℤ), natAbs (a + b) = max (natAbs a) (natAbs b) - min (natAbs a) (natAbs b)
natAbs_addWarning: declaration uses 'sorry' (a: ℤ
a b: ℤ
b : ℤ: Type
ℤ) : natAbs: ℤ → ℕ
natAbs (a: ℤ
a + b: ℤ
b) = max: {α : Type ?u.54532} → [self : Max α] → α → α → α
max (natAbs: ℤ → ℕ
natAbs a: ℤ
a) (natAbs: ℤ → ℕ
natAbs b: ℤ
b) - min: {α : Type ?u.54538} → [self : Min α] → α → α → α
min (natAbs: ℤ → ℕ
natAbs a: ℤ
a) (natAbs: ℤ → ℕ
natAbs b: ℤ
b) := by R: Type u

inst✝: IntegralDomain R

a, b: ℤ

natAbs (a + b) = max (natAbs a) (natAbs b) - min (natAbs a) (natAbs b)sorry
Goals accomplished! 🐙

lemma int_val_add_ge_min: ∀ (p : ℕ) (a b : ℤ), int_val p (a + b) ≥ min (int_val p a) (int_val p b)
int_val_add_ge_minWarning: declaration uses 'sorry' (p: ℕ
p : ℕ: Type
ℕ) (a: ℤ
a b: ℤ
b : ℤ: Type
ℤ) : int_val: ℕ → ℤ → ℕ∪∞
int_val p: ℕ
p (a: ℤ
a + b: ℤ
b) ≥ min: {α : Type ?u.54644} → [self : Min α] → α → α → α
min (int_val: ℕ → ℤ → ℕ∪∞
int_val p: ℕ
p a: ℤ
a) (int_val: ℕ → ℤ → ℕ∪∞
int_val p: ℕ
p b: ℤ
b) := by
  R: Type u

inst✝: IntegralDomain R

p: ℕ

a, b: ℤ

int_val p (a + b) ≥ min (int_val p a) (int_val p b)simp [int_val: ℕ → ℤ → ℕ∪∞
int_val, natAbs_add: ∀ (a b : ℤ), natAbs (a + b) = max (natAbs a) (natAbs b) - min (natAbs a) (natAbs b)
natAbs_add]R: Type u

inst✝: IntegralDomain R

p: ℕ

a, b: ℤ

nat_valuation p (max (natAbs a) (natAbs b) - min (natAbs a) (natAbs b)) ≥   min (nat_valuation p (natAbs a)) (nat_valuation p (natAbs b))
  -- exact nat_val_add_ge_min p (natAbs a) (natAbs b)
  R: Type u

inst✝: IntegralDomain R

p: ℕ

a, b: ℤ

int_val p (a + b) ≥ min (int_val p a) (int_val p b)sorry
Goals accomplished! 🐙

lemma int_val_add_eq_min: ∀ (p : ℕ) (a b : ℤ), int_val p a < int_val p b → int_val p (a + b) = int_val p a
int_val_add_eq_minWarning: declaration uses 'sorry' (p: ℕ
p : ℕ: Type
ℕ) (a: ℤ
a b: ℤ
b : ℤ: Type
ℤ) (h: int_val p a < int_val p b
h : int_val: ℕ → ℤ → ℕ∪∞
int_val p: ℕ
p a: ℤ
a < int_val: ℕ → ℤ → ℕ∪∞
int_val p: ℕ
p b: ℤ
b) :
  int_val: ℕ → ℤ → ℕ∪∞
int_val p: ℕ
p (a: ℤ
a + b: ℤ
b) = int_val: ℕ → ℤ → ℕ∪∞
int_val p: ℕ
p a: ℤ
a := by R: Type u

inst✝: IntegralDomain R

p: ℕ

a, b: ℤ

h: int_val p a < int_val p b

int_val p (a + b) = int_val p asorry
Goals accomplished! 🐙

lemma int_val_eq_top_iff_zero: ∀ (p : ℕ), 1 < p → ∀ (a : ℤ), int_val p a = ∞ ↔ a = 0
int_val_eq_top_iff_zeroWarning: declaration uses 'sorry' (p: ℕ
p : ℕ: Type
ℕ) (gt1: 1 < p
gt1 : 1: ?m.54986
1 < p: ℕ
p) (a: ℤ
a : ℤ: Type
ℤ) : int_val: ℕ → ℤ → ℕ∪∞
int_val p: ℕ
p a: ℤ
a = ∞: ℕ∪∞
∞ ↔ a: ℤ
a = 0: ?m.55027
0 := by R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < p

a: ℤ

int_val p a = ∞ ↔ a = 0sorry
Goals accomplished! 🐙

def primeVal: {p : ℕ} → nat_prime p → SurjVal ↑p
primeVal {p: ℕ
p : ℕ: Type
ℕ} (hp: nat_prime p
hp : nat_prime: ℕ → Prop
nat_prime p: ℕ
p) : SurjVal: {R : Type ?u.55068} → R → [inst : IntegralDomain R] → Type ?u.55068
SurjVal (ofNat: ℕ → ℤ
ofNat p: ℕ
p) := {
  v := int_val: ℕ → ℤ → ℕ∪∞
int_val p: ℕ
p,
  v_uniformizer := int_val_uniformizer: ∀ {p : ℕ}, 1 < p → int_val p ↑p = ofN 1
int_val_uniformizer hp: nat_prime p
hp.left: ∀ {a b : Prop}, a ∧ b → a
left,
  v_mul_eq_add_v := int_val_mul_eq_add: ∀ (p : ℕ), nat_prime p → ∀ (a b : ℤ), int_val p (a * b) = int_val p a + int_val p b
int_val_mul_eq_add p: ℕ
p hp: nat_prime p
hp,
  v_add_ge_min_v := int_val_add_ge_min: ∀ (p : ℕ) (a b : ℤ), int_val p (a + b) ≥ min (int_val p a) (int_val p b)
int_val_add_ge_min p: ℕ
p,
  v_eq_top_iff_zero := int_val_eq_top_iff_zero: ∀ (p : ℕ), 1 < p → ∀ (a : ℤ), int_val p a = ∞ ↔ a = 0
int_val_eq_top_iff_zero p: ℕ
p hp: nat_prime p
hp.left: ∀ {a b : Prop}, a ∧ b → a
left
  }

def decr_val_p: ℕ → (ℤ → ℕ∪∞) → ℤ → ℤ
decr_val_p (p: ℕ
p : ℕ: Type
ℕ) (val: ℤ → ℕ∪∞
val : ℤ: Type
ℤ → ℕ∪∞: Type
ℕ∪∞) (k: ℤ
k : ℤ: Type
ℤ) : ℤ: Type
ℤ :=
  match val: ℤ → ℕ∪∞
val k: ℤ
k with
  | 0: ℕ∪∞
0 => k: ℤ
k
  | _ => k: ℤ
k / p: ℕ
p

lemma zero_valtn_decr_p: ∀ {p : ℕ} {k : ℤ} (val : ℤ → ℕ∪∞), val k = 0 → decr_val_p p val k = k
zero_valtn_decr_p {p: ℕ
p: ℕ: Type
ℕ} {k: ℤ
k : ℤ: Type
ℤ} (val: ℤ → ℕ∪∞
val : ℤ: Type
ℤ → ℕ∪∞: Type
ℕ∪∞) (h: val k = 0
h : val: ℤ → ℕ∪∞
val k: ℤ
k = 0: ?m.55869
0) : decr_val_p: ℕ → (ℤ → ℕ∪∞) → ℤ → ℤ
decr_val_p p: ℕ
p val: ℤ → ℕ∪∞
val k: ℤ
k = k: ℤ
k :=
by R: Type u

inst✝: IntegralDomain R

p: ℕ

k: ℤ

val: ℤ → ℕ∪∞

h: val k = 0

decr_val_p p val k = krw [R: Type u

inst✝: IntegralDomain R

p: ℕ

k: ℤ

val: ℤ → ℕ∪∞

h: val k = 0

decr_val_p p val k = kdecr_val_p: ℕ → (ℤ → ℕ∪∞) → ℤ → ℤ
decr_val_p,R: Type u

inst✝: IntegralDomain R

p: ℕ

k: ℤ

val: ℤ → ℕ∪∞

h: val k = 0

(match val k with
  | ofN Nat.zero => k
  | x => k / ↑p) =   k R: Type u

inst✝: IntegralDomain R

p: ℕ

k: ℤ

val: ℤ → ℕ∪∞

h: val k = 0

decr_val_p p val k = kh: val k = 0
hR: Type u

inst✝: IntegralDomain R

p: ℕ

k: ℤ

val: ℤ → ℕ∪∞

h: val k = 0

(match 0 with
  | ofN Nat.zero => k
  | x => k / ↑p) =   k]
Goals accomplished! 🐙

def norm_repr_p: ℕ → ℤ → ℤ
norm_repr_p (p: ℕ
p : ℕ: Type
ℕ) (x: ℤ
x : ℤ: Type
ℤ) : ℤ: Type
ℤ := (x: ℤ
x % (p: ℕ
p : ℤ: Type
ℤ) + p: ℕ
p) % (p: ℕ
p : ℤ: Type
ℤ)

lemma def_char_p: ∀ {p : ℕ} {hp : nat_prime p} (p_1 n : ℕ), SurjVal.v (primeVal hp) ↑n > 0 ↔ p_1 ∣ n
def_char_pWarning: declaration uses 'sorry' (p: ℕ
p : ℕ: Type
ℕ) : ∀ n: ℕ
n : ℕ: Type
ℕ, (primeVal: {p : ℕ} → nat_prime p → SurjVal ↑p
primeVal hp: ?m.56470
hp).v: {R : Type ?u.56482} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v n: ℕ
n > 0: ?m.56578
0 ↔ p: ℕ
p ∣ n: ℕ
n := sorry: ?m.56810
sorry

def primeEVR: {p : ℕ} → nat_prime p → EnatValRing ↑p
primeEVRWarning: declaration uses 'sorry' {p: ℕ
p : ℕ: Type
ℕ} (hp: nat_prime p
hp : nat_prime: ℕ → Prop
nat_prime p: ℕ
p) : EnatValRing: {R : Type ?u.56827} → R → [inst : IntegralDomain R] → Type ?u.56827
EnatValRing (p: ℕ
p : ℤ: Type
ℤ) := {
  valtn := primeVal: {p : ℕ} → nat_prime p → SurjVal ↑p
primeVal hp: nat_prime p
hp,
  decr_val := decr_val_p: ℕ → (ℤ → ℕ∪∞) → ℤ → ℤ
decr_val_p p: ℕ
p (primeVal: {p : ℕ} → nat_prime p → SurjVal ↑p
primeVal hp: nat_prime p
hp).v: {R : Type ?u.56938} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v,
  zero_valtn_decr := zero_valtn_decr_p: ∀ {p : ℕ} {k : ℤ} (val : ℤ → ℕ∪∞), val k = 0 → decr_val_p p val k = k
zero_valtn_decr_p (primeVal: {p : ℕ} → nat_prime p → SurjVal ↑p
primeVal hp: nat_prime p
hp).v: {R : Type ?u.56952} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v,
  pos_valtn_decr := sorry: ?m.56979
sorry,
  residue_char := p: ℕ
p,
  def_char := def_char_p: ∀ {p : ℕ} {hp : nat_prime p} (p_1 n : ℕ), SurjVal.v (primeVal hp) ↑n > 0 ↔ p_1 ∣ n
def_char_p p: ℕ
p,
  norm_repr := norm_repr_p: ℕ → ℤ → ℤ
norm_repr_p p: ℕ
p,
  quad_roots_in_residue_field := fun a: ?m.58104
a b: ?m.58107
b c: ?m.58110
c => Int.quad_root_in_ZpZ: ℤ → ℤ → ℤ → ℕ → Bool
Int.quad_root_in_ZpZ a: ?m.58104
a b: ?m.58107
b c: ?m.58110
c p: ℕ
p
}

lemma prime_2: nat_prime 2
prime_2Warning: declaration uses 'sorry' : nat_prime: ℕ → Prop
nat_prime 2: ?m.58359
2 := by
  R: Type u

inst✝: IntegralDomain R

nat_prime 2simp only [nat_prime: ℕ → Prop
nat_prime, true_and: ∀ (p : Prop), (True ∧ p) = p
true_and]R: Type u

inst✝: IntegralDomain R

∀ (a b : ℕ), a * b % 2 = 0 → a % 2 = 0 ∨ b % 2 = 0
  R: Type u

inst✝: IntegralDomain R

nat_prime 2sorry
Goals accomplished! 🐙
lemma prime_3: nat_prime 3
prime_3Warning: declaration uses 'sorry' : nat_prime: ℕ → Prop
nat_prime 3: ?m.58569
3 := by
  R: Type u

inst✝: IntegralDomain R

nat_prime 3simp only [nat_prime: ℕ → Prop
nat_prime, true_and: ∀ (p : Prop), (True ∧ p) = p
true_and]R: Type u

inst✝: IntegralDomain R

∀ (a b : ℕ), a * b % 3 = 0 → a % 3 = 0 ∨ b % 3 = 0
  R: Type u

inst✝: IntegralDomain R

nat_prime 3sorry
Goals accomplished! 🐙

def modulo: (x : ℤ) → (p : ℕ) → ?m.58783 x p
modulo (x: ℤ
x : ℤ: Type
ℤ) (p: ℕ
p : ℕ: Type
ℕ) := (x: ℤ
x % (p: ℕ
p:ℤ: Type
ℤ) + p: ℕ
p) % (p: ℕ
p:ℤ: Type
ℤ)

def inv_mod: (x : ℤ) → (p : ℕ) → ?m.59086 x p
inv_mod (x: ℤ
x : ℤ: Type
ℤ) (p: ℕ
p : ℕ: Type
ℕ) := modulo: ℤ → ℕ → ℤ
modulo (x: ℤ
x ^ (p: ℕ
p - 2: ?m.59101
2)) p: ℕ
p

def has_double_root: (a b c : ℤ) → {p : ℕ} → (hp : nat_prime p) → ?m.59371 a b c hp
has_double_root (a: ℤ
a b: ℤ
b c: ℤ
c : ℤ: Type
ℤ) {p: ℕ
p : ℕ: Type
ℕ} (hp: nat_prime p
hp : nat_prime: ℕ → Prop
nat_prime p: ℕ
p) :=
  let v_p: ?m.59379
v_p := (primeEVR: {p : ℕ} → nat_prime p → EnatValRing ↑p
primeEVR hp: nat_prime p
hp).valtn: {R : Type ?u.59382} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.59392} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v;
  v_p: ?m.59379
v_p a: ℤ
a = 0: ?m.59415
0 ∧ v_p: ?m.59379
v_p (b: ℤ
b ^ 2: ?m.59651
2 - 4: ?m.59667
4 * a: ℤ
a * c: ℤ
c) > 0: ?m.59888
0

def double_root: (a b c : ℤ) → (p : ℕ) → ?m.60158 a b c p
double_root (a: ℤ
a b: ℤ
b c: ℤ
c : ℤ: Type
ℤ) (p: ℕ
p : ℕ: Type
ℕ) :=
  if p: ℕ
p = 2: ?m.60166
2 then
    modulo: ℤ → ℕ → ℤ
modulo c: ℤ
c 2: ?m.60200
2
  else
    modulo: ℤ → ℕ → ℤ
modulo (-b: ℤ
b * inv_mod: ℤ → ℕ → ℤ
inv_mod (2: ?m.60210
2 * a: ℤ
a) p: ℕ
p) p: ℕ
p

lemma val_poly_of_double_root: ∀ {p : ℕ} (hp : nat_prime p) (a b c : ℤ),
  has_double_root a b c hp →
    let x := double_root a b c p;
    let v_p := (primeEVR hp).valtn.v;
    v_p (a * x ^ 2 + b * x + c) > 0 ∧ v_p (2 * a * x + b) > 0
val_poly_of_double_rootWarning: declaration uses 'sorry' {p: ℕ
p : ℕ: Type
ℕ} (hp: nat_prime p
hp : nat_prime: ℕ → Prop
nat_prime p: ℕ
p) (a: ℤ
a b: ℤ
b c: ℤ
c : ℤ: Type
ℤ) (H: has_double_root a b c hp
H : has_double_root: ℤ → ℤ → ℤ → {p : ℕ} → nat_prime p → Prop
has_double_root a: ℤ
a b: ℤ
b c: ℤ
c hp: nat_prime p
hp) : let x: ?m.60429
x := double_root: ℤ → ℤ → ℤ → ℕ → ℤ
double_root a: ℤ
a b: ℤ
b c: ℤ
c p: ℕ
p; let v_p: ?m.60432
v_p := (primeEVR: {p : ℕ} → nat_prime p → EnatValRing ↑p
primeEVR hp: nat_prime p
hp).valtn: {R : Type ?u.60434} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.60444} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v; v_p: ?m.60432
v_p (a: ℤ
a*x: ?m.60429
x^2: ?m.60469
2 + b: ℤ
b*x: ?m.60429
x + c: ℤ
c) > 0: ?m.60696
0 ∧ v_p: ?m.60432
v_p (2: ?m.61008
2*a: ℤ
a*x: ?m.60429
x + b: ℤ
b) > 0: ?m.61092
0 := by R: Type u

inst✝: IntegralDomain R

p: ℕ

hp: nat_prime p

a, b, c: ℤ

H: has_double_root a b c hp

let x := double_root a b c p;
let v_p := (primeEVR hp).valtn.v;
v_p (a * x ^ 2 + b * x + c) > 0 ∧ v_p (2 * a * x + b) > 0sorry
Goals accomplished! 🐙



end Int